Tema07

Universidad & Salamanca

Ingeniería Superior Informática.

TEMA 7 Colores y Sombras

Informática Gráfica

José María Corral Martín Álvaro F. García Sánchez

Colores y sombras 2

7.1. Introducción................................................................................................. 4 7.2. ¿Qué es el color? ........................................................................................ 4

7.2.1. La luz como Onda................................................................................. 5 7.2.2. La luz como partícula............................................................................ 6 7.2.3. Dualidad onda - partícula...................................................................... 6

7.3. Percepción del color.................................................................................... 6 7.3.1. Características psicológicas del color ................................................... 7

7.4. Dispositivos de visualización ....................................................................... 9 7.4.1. TRC ...................................................................................................... 9

7.4.1.1. Análisis de los tiempos involucrados............................................ 10 7.4.1.2. Exploración de línea..................................................................... 10 7.4.1.3. Sincronizaciones horizontales y verticales ................................... 11

7.4.2. LCD..................................................................................................... 12 7.4.2.1. Funcionamiento............................................................................ 14 7.4.2.2 LCD de texto ................................................................................. 14 7.4.2.3. TFT............................................................................................... 14

7.4.3. Pantalla de plasma ............................................................................. 15 7.5. El monitor vs. El ojo................................................................................... 16 7.6. Profundidad del color ................................................................................ 16

7.6.1. Color de 1-bit ...................................................................................... 16 7.6.2. Color de 4-bits .................................................................................... 17 7.6.3. Color de 8-bits .................................................................................... 18 7.6.4. Color de 24-bits .................................................................................. 18

7.7. Modelos de color ....................................................................................... 19 7.7.1. Modelo de color XYZ .......................................................................... 19

7.7.1.1. Espacio de color CIE.................................................................... 19 7.7.1.1.1. Diagrama de cromaticidad CIE .............................................. 20 7.7.1.1.2. Gama de colores ................................................................... 20

7.7.2. El modelo de color RGB ..................................................................... 21 7.7.3. El modelo de color CMY (Cyan, Magenta, Amarillo)........................... 23 7.7.4. El modelo de color YUV...................................................................... 24 7.7.5. El modelo de color YIQ ....................................................................... 24 7.7.6. El modelo de color HSI ....................................................................... 25 7.7.7. El sistema HLS (Hue, Saturation and Luminance).............................. 26 7.7.8. Modelo HSV........................................................................................ 26

7.8. Colores en OpenGL .................................................................................. 28 7.8.1. Utilización de colores con OpenGL..................................................... 28 7.8.2. Modelo de color RGBA ....................................................................... 30 7.8.3. Modelo de color indexado................................................................... 36 7.8.4. Modelo de color RGBA vs. Modelo de color Indexado........................ 48 7.8.5. Ocultaciones ....................................................................................... 49

7.8.5.1. Algoritmo de las caras de detrás.................................................. 49 7.8.5.2 Algoritmo del Z-buffer.................................................................... 50 7.8.5.3. Combinando ambos algoritmos.................................................... 51

7.8.6. El color de los materiales.................................................................... 52 7.9. Sombras.................................................................................................... 58

7.9.1 Efecto falloff (Distance falloff) .............................................................. 60 7.9.2 Sombreado .......................................................................................... 61 7.9.3 Tipos de sombreado ............................................................................ 62

7.9.3.1 Sombreado plano (Flat Shading)................................................... 62

Colores y sombras 3

7.9.3.2 Sombreado de Gouraud................................................................ 63 7.9.3.3 Sombreado de Phong ................................................................... 65 7.9.3.4 Sombreado Blinn–Phong .............................................................. 67

7.9.4 Sombreado en OpenGL....................................................................... 68 7.9.4.1 Sombreado Plano (Flat) ................................................................ 68 7.9.4.2 Sombreado Interpolativo y Gouraud.............................................. 70 7.9.4.3 Stencil Buffer................................................................................. 71 7.9.4.4 Buffer de Profundidad o Z buffer ................................................... 75

7.9.5. Volúmenes de sombras ...................................................................... 76 7.9.5.1 Paso de profundidad (Depth pass)................................................ 78 7.9.5.2 Error de Profundidad (Depth fail)................................................... 78 7.9.7.3 OR exclusivo ................................................................................ 78

7.10 Fusión (Dithering)..................................................................................... 78 7.11. Creación de Paletas de Ventana............................................................. 80

7.11.1 Arbitraje de paletas............................................................................ 80 7.11.2. Creación de una paleta..................................................................... 82 7.11.3 Estructura de la paleta. ...................................................................... 82 7.11.4 Destrucción de una paleta. ............................................................... 85

7.12 Conclusión................................................................................................ 87 7.13 Otras funciones para luces y sombras ..................................................... 87

glAccum........................................................................................................ 87 glColorMask.................................................................................................. 88 glDrawBuffer ................................................................................................. 88 glFog............................................................................................................. 89 glIndexMask.................................................................................................. 90 glIsEnabled................................................................................................... 90 glLogicOp...................................................................................................... 90 glPolygonMode ............................................................................................. 91

7.14 Bibliografia................................................................................................ 92 7.15 Enlaces de interés.................................................................................... 96

Colores y sombras 4

7.1. Introducción

Los despliegues realistas de objetos se obtienen generando proyecciones en perspectiva con superficies ocultas eliminadas y después aplicando modelos de sombreado y color a las superficies visibles. Un modelo de sombreado se utiliza para calcular la intensidad de luz que debe observarse cuando se visualiza una superficie. Estos cálculos de intensidad se basan en las propiedades ópticas de las superficies, las posiciones relativas de las superficies y su orientación con respecto a las fuentes de luz.

En este tema se introducirán los conceptos de color y sombreado,

algunos de los modelos más utilizados actualmente para su representación para posteriormente mostrar todo lo necesario para la utilización del color y del sombreado en escenas con OpenGL con multitud de ejemplos sencillos. 7.2. ¿Qué es el color?

El color de un objeto percibido por la vista se debe a las propiedades inherentes al mismo, de reflejar, seleccionar y absorber determinados rayos de los que integran la luz blanca. La luz solar es un fenómeno vibratorio de innumerables variaciones en cuanto a longitud de onda. Al pasar la luz por un prisma se ve que está compuesta por un sinnúmero de colores; los fundamentales son: violeta (que corresponde a la vibración más pequeña y simple), añil, azul, verde, amarilla, naranja y rojo. El color negro resulta de la ausencia de toda impresión luminosa.

Diccionario Enciclopédico Abreviado Espasa-Calpe.S.A Según la definición el color de un objeto se debe a la combinación de las

distintas longitudes de onda que el objeto refleja, así por ejemplo un objeto rojo sería aquel que absorbiese todos los rayos que componen la luz blanca menos el de menor longitud de onda (el rojo).

El color en las artes es el medio más valioso para que una obra

transmita las mismas sensaciones que el artista experimenta frente a la escena o motivo original; utilizando el color adecuadamente y con conocimiento de su naturaleza y efectos será posible expresar la alegría o tristeza, la luminosidad u oscuridad, tranquilidad o la exaltación, etc.

El color en la informática gráfica se desenvuelve de la misma manera

que en el arte de la pintura, aunque en su actuación va mucho mas allá porque su fin es especialmente especifico, puede servir para favorecer, destacar, disimular y aún ocultar, para crear una sensación excitante o tranquila, para denotar temperatura, tamaño, profundidad o peso y como la música, puede ser utilizada deliberadamente para despertar un sentimiento.

El color tiene su propia técnica y está sometido a ciertas leyes,

conociéndolas será posible dominar el arte de la armonización, conocer los medios útiles que sirven para evitar la monotonía en una combinación

Colores y sombras 5

cromática, estimular la facultad del gusto selectivo y afirmar la sensibilidad, desconociéndolas es posible trastornar y anular las percepciones deseadas.

7.2.1. La luz como Onda

Lo que percibimos como color es una banda de frecuencias del espectro

electromagnético, otras bandas de frecuencias incluidas en el espectro son las ondas de radio, infrarrojos, etc. Cada frecuencia contenida en el espectro visible se corresponde con un color distinto.

El espectro visible abarca desde los 4.3*1014 Hz (rojo) hasta los 7.5 * 10 14 Hz (violeta). En este intervalo de frecuencias el ojo humano distingue aproximadamente unos 400.000 colores diferentes (esta gama se extiende desde el rojo pasando por el anaranjado y amarillo en el extremo de las bajas frecuencias hasta los azules y violetas de las altas frecuencias).

Figura 2 - Espectro Electromagnético

Lo que se designa como luz blanca es la impresión creada por el

conjunto de radiaciones que son visibles por nuestro ojo; la luz blanca cuando es descompuesta produce el fenómeno de arco iris, estos son los que llamamos colores, el conjunto de estos, o franja continua de longitudes de onda creada por la luz al descomponerse, constituye el espectro.

Describimos los colores en función de su frecuencia o de su longitud de

onda dado que la luz es una onda electromagnética (C = λ*f). La longitud de onda en el espectro visible varía desde los 720 nanómetros del rojo a los 390 nanómetros del violeta.

Cualquier fuente de luz (sol, foco de luz ...) emite todas las

frecuencias en el intervalo visible para producir la luz blanca.

Figura 1 - Estructura de una onda

Colores y sombras 6

Un objeto sobre el que incide luz blanca absorberá algunas frecuencias y reflejará otras. La combinación de éstas últimas determinará el color del objeto. Describimos el objeto como violeta si predominan las altas frecuencias en la luz reflejada, es decir, la luz tiene una frecuencia dominante o longitud de onda dominante en el extremo violeta del espectro. La frecuencia dominante se denomina color o matiz de la luz.

7.2.2. La luz como partícula

La luz puede ser descrita como una onda oscilante, pero también puede

ser considerada como un haz de partículas viajando a altas velocidades (3,0 x 108 m/s). Los haces de luz están compuestos por partículas denominadas fotones.

A nivel físico, los llamados colores compuestos, están hechos de

diversas cantidades de de colores “puros” encontrados en el espectro. Al iluminar cualquier objeto dado con una fuente de luz es golpeado por

“billones y billones” de fotones, o pequeñas partículas de luz, algunos de ellos serán absorbidos y otros reflejados. La reflexión de la luz sobre un objeto depende del tipo, distribución y cantidad de átomos que contenga.

Cada uno de esos fotones es también una onda, con su correspondiente

longitud de onda y por tanto un color específico en el espectro.

7.2.3. Dualidad onda - partícula La frecuencia (υ) de la teoría de las ondas se puede relacionar con la

teoría del fotón (E) de la teoría de la partícula a través de la ecuación de Planck:

E = h υ donde h es la constante de planck (factor de proporcionalidad = 6,63 x

10-34 (Js)). La frecuencia (υ) de una determinada onda es inversamente

proporcional a su longitud de onda.

7.3. Percepción del color

El color es la impresión producida al incidir en la retina los rayos luminosos difundidos o reflejados por los cuerpos. El ojo humano es capaz de captar las variaciones de la longitud de onda del espectro electromagnético visualizándolo como diferentes colores, desde el violeta hasta el rojo.

Colores y sombras 7

Este fenómeno se debe al aspecto físico de la radiación, el ojo humano que actúa como sensor y el cerebro que es capaz de percibir, diferenciar e interpretar las imágenes que conforman este espectro.

La retina del ojo, a

través de una estructura formada por unos elementos denominados bastones (concentrados en los lados de la retina) y conos (concentrados en el centro), tiene la capacidad para discernir los colores, la

forma, los detalles y la posición de los objetos.

Los conos están especializados en la visión del color, así unos ven

solamente el azul y el violeta, otros el verde y el amarillo y otros el rojo y el naranja. Además, es capaz de adaptarse a las diferentes cantidades de luz y al brillo de las escenas y discernir e identificar los diferentes colores.

Los bastones al contrario que los conos requieren muy poca luz, lo que

los hace muy adecuados para la visión nocturna, sin embargo, no son capaces de discernir los colores.

Los fotones penetran en nuestro ojo enfocándose en la retina, ésta actúa

como una película fotográfica. Las células de la retina son excitadas por los fotones, lo cual provoca un estímulo que es transmitido por las neuronas al cerebro.

El cerebro interpreta esta información como luz y color. El nivel de

excitación es proporcional al número de fotones que llegan a la retina.

7.3.1. Características psicológicas del color

Necesitamos otras propiedades, además de la frecuencia, para caracterizar nuestra percepción de la luz.

La cromaticidad hace referencia al conjunto de variables del color que

se utilizan normalmente para describir las diferentes propiedades de una fuente de luz.

- El matiz es el croma de un color y depende de la longitud de onda

dominante. Es la cualidad que permite clasificar a los colores como amarillo, rojo, violeta, etc. El matiz se mide de acuerdo con la proximidad que tiene un color con relación a otro que se halle próximo en el círculo cromático; por ejemplo: verde amarillento, naranja rojizo, azul violáceo, etcétera

Figura 3 - Sección de un ojo humano

Colores y sombras 8

Figura 4 – Matiz

- Valor o luminosidad indica las luminancias de un color; es decir, el

grado de claridad u oscuridad que posee como cualidad intrínseca. Dentro del círculo cromático, el amarillo es el color de mayor luminancia y el violeta el de menor. Independientemente de los valores propios de los colores, éstos se pueden alterar mediante la adición de blanco que lleva el color a claves o valores de luminancia más altos, o de negro que los disminuye.

- El tono es la resultante de la mezcla de los colores con blanco o negro y tiene referencia de valor y de matiz. Por ejemplo, el amarillo mezclado con negro modifica su matiz hacia el verde y se oscurece.

Figura 5 - Tono

- La saturación se refiere al grado de pureza de un color y se mide

con relación al gris. Los colores muy saturados poseen mayor grado de pureza y se presentan con más intensidad luminosa en relación con su valor. Los colores con menor saturación se muestran más agrisados, con mayor cantidad de impurezas y con menor intensidad luminosa.

Figura 6 - Saturación

Se utilizan modelos de color con combinaciones de luz en términos de

frecuencia dominante haciendo uso de 3 colores para obtener una gama amplia de colores. Esto se suele denominar gama de color del modelo. Los tres colores utilizados en el modelo se denominan colores primarios.

Ningún conjunto de colores primarios describe todas las frecuencias del

espectro visible. Agregando colores primarios aumentamos el número de posibles colores pero harían falta un número infinito de colores para poder representar todos los posibles colores. Para muchos fines con los tres colores

Colores y sombras 9

primarios es suficiente, sino se puede representar un color concreto se pueden utilizar métodos extendidos.

Cuando se proyectan juntas luces rojas, verdes y azules, obtenemos el

blanco. Los colores secundarios se obtienen de la mezcla de los colores

primarios.

Figura 8 - Colores Secundarios

7.4. Dispositivos de visualización 7.4.1. TRC

Un monitor para mostrar una imagen utiliza un tubo de rayos catódicos

(TRC) cuyo frente se "ilumina" con un cañón de electrones localizado en la parte posterior del tubo, el cual dispara un haz de electrones muy concentrado que al impactar con el material sensible del frente del tubo lo excita iluminando los puntos que componen la imagen.

La forma en

que el haz "barre" la pantalla para desplegar una imagen se denomina deflexión. Ésta se realiza excitando convenientemente un juego de bobinas (def. Horizontal y def. Vertical) que están colocadas de forma muy precisa en el cuello del TRC. El campo magnético que generan al ser excitadas desvía el haz para conseguir que apunten al frente del tubo a la posición deseada.

Un monitor no forma la imagen, ésta se procesa y forma en la placa de

video del ordenador. Después se almacena en la memoria de video y se envía esta información (señales de video y sincronización) al monitor. Éste la toma y la ordena para poder mostrarla, para ello se utilizan dos señales de

Figura 7 - Colores Primarios

Figura 9 - Tubo de rayos catódicos

Colores y sombras 10

sincronización de eventos consiguiendo que la imagen se muestre de forma coherente y ordenada. La señales de sincronismo horizontal y vertical se generan en la placa de video y sus características dependen del modo de video elegido (resolución).

7.4.1.1. Análisis de los tiempos involucrados

Tiempo activo horizontal Para desplegar una imagen, el haz apunta a la esquina superior-

izquierda de la pantalla y se mueve horizontalmente hasta el derecho de la misma. El tiempo que emplea el haz para desplazarse del lado izquierdo al derecho se denomina "tiempo activo horizontal".

Retardo Horizontal o tiempo de borrado Es el tiempo utilizado en el regreso del haz a la izquierda de la pantalla

cuando éste ha alcanzado el lado derecho de la misma. Tiempo Total horizontal El haz cumple un ciclo horizontal completo cuando, empezando en el

borde izquierdo de la pantalla va hacia el lado derecho, y regresa atrás de nuevo. Este “tiempo total horizontal” se obtiene sumando los tiempos de Retardo Horizontal y Activo Horizontal

Velocidad de Refresco Horizontal Dependiendo de la velocidad con la que el monitor puede trabajar,

pueden ocurrir cada segundo unos 20.000 a 80.000 ciclos horizontales . El número de ciclos horizontales por segundo es denominado Refresco Horizontal y normalmente está en KHz.

Tiempo Total Horizontal Cuando trabajamos con la velocidad horizontal de un monitor

generalmente utilizamos el Refresco Horizontal. Sin embargo, al tratar con los ciclos horizontales de un monitor específico, normalmente utilizaremos el tiempo real de cada ciclo horizontal. El ciclo horizontal de un monitor es la suma de los tiempos real horizontal y tiempo de borrado o retrazo.

7.4.1.2. Exploración de línea

Para desplegar una imagen completa no sólo hay que desplegar el haz

“de izquierda a derecha” de la pantalla, es decir, horizontalmente, sino también “de arriba abajo”, es decir, verticalmente. Cada recorrido horizontal del haz se llama exploración de línea "scanline”.


Tiempo activo vertical Es el tiempo total que necesita el monitor para desplegar todas las líneas

horizontales. Dependiendo de la resolución vertical de un monitor, una imagen en la pantalla puede componerse de 320 a 1600 líneas horizontales.

Retrazo o borrado vertical o tiempo de retardo Es el tiempo que necesita el haz para una vez que ha alcanzado la

esquina inferior derecha de la pantalla retornar rápidamente a la parte superior izquierda de la misma.

Tiempo Total Vertical Es el tiempo que utiliza el haz para "barrer" desde la parte superior hasta

la inferior de la pantalla y volver a la esquina superior-izquierda. Tiempo Total Vertical = Tiempo activo Vertical + Tiempo de Retrazo

Vertical Velocidad de Refresco Vertical o refresco vertical de un monitor Es el número de ciclos verticales completados por segundo medido en

Hz. Raster: Es el ciclo completo de formación de un cuadro de imagen

7.4.1.3. Sincronizaciones horizontales y verticales

Señal de sincronización vertical Utilizando esta señal el monitor controla el regreso del haz desde la

esquina inferior-derecha a la esquina superior-izquierda Señal de sincronización Horizontal Con esta señal el monitor controla el regreso del haz desde el lado

derecho al izquierdo Pulso de Sincronización horizontal y posición de la imagen Durante el tiempo de retardo horizontal el monitor recibe el pulso de

sincronización horizontal. El tiempo entre el extremo del tiempo activo horizontal y la salida del pulso de la sincronización horizontal se denomina el Porche Delantero Horizontal.

El tiempo durante el cual el pulso de sincronización horizontal

permanece activo, se denomina Ancho de Sincronización Horizontal. Después de recibir el pulso de la sincronización horizontal, el monitor

devuelve el haz al lado izquierdo de la pantalla. El periodo de tiempo entre el extremo del pulso de la Sincronización Horizontal y el comienzo del próximo tiempo activo horizontal es denominado Porche Trasero Horizontal.


Modificando la posición del pulso de la sincronización horizontal respecto

al tiempo de retrazo horizontal se ajusta la posición de la imagen en la pantalla a la derecha o izquierda.

Figura 10 - Pulso de sincronización horizontal

Pulso de Sincronización vertical y posición de imagen Durante el tiempo de retrazo vertical el monitor recibe el pulso de la

sincronización vertical. El tiempo entre el extremo del tiempo activo vertical y la salida del pulso de la sincronización vertical se llama el Porche Delantero Vertical.

El tiempo durante el cual el pulso de la sincronización vertical

permanece activo se denomina la Anchura de la Sincronización Vertical. Después de recibir el pulso de la sincronización vertical, el monitor devuelve el haz al tope de la pantalla.

El periodo de tiempo entre el extremo del pulso de la Sincronización

Vertical y la salida del próximo tiempo activo vertical es el Porche Trasero Vertical.

Modificando la posición del pulso de la sincronización vertical respecto al

tiempo de retardo vertical se ajusta la situación de la imagen en la pantalla arriba o abajo.

7.4.2. LCD

LCD (Liquid Crystal Display) son las siglas en inglés de Pantalla de

Cristal Líquido , dispositivo inventado por Jack Janning, quien fue empleado de NCR.

Se trata de un sistema eléctrico de presentación de datos formado por 2 capas conductoras transparentes y en medio un material especial cristalino (cristal líquido) que tienen la capacidad de orientar la luz a su paso.


Cuando la corriente circula entre los electrodos transparentes con la forma a representar (por ejemplo, un segmento de un número) el material cristalino se reorienta alterando su transparencia.

El material base de un LCD lo constituye el cristal líquido, el cual exhibe

un comportamiento similar al de los líquidos y unas propiedades físicas anisotrópicas similares a las de los sólidos cristalinos. Las moléculas de cristal líquido poseen una forma alargada y son más o menos paralelas entre sí en la fase cristalina. Según la disposición molecular y su ordenamiento, se clasifican en tres tipos: nemáticos, esméticos y colestéricos. La mayoría de cristales responden con facilidad a los campos eléctricos, exhibiendo distintas propiedades ópticas en presencia o ausencia del campo. El tipo más común de visualizador LCD es, con mucho, el denominado nemático de torsión, término que indica que sus moléculas en su estado desactivado presentan una disposición en espiral. La polarización o no de la luz que circula por el interior de la estructura, mediante la aplicación o no de un campo eléctrico exterior, permite la activación de una serie de segmentos transparentes, los cuales rodean al cristal líquido. Según sus características ópticas, pueden también clasificarse como: reflectivos, transmisivos y transreflectivos.

Las pantallas LCD se encuentran en multitud de dispositivos industriales

y de consumo: máquinas expendedoras, electrodomésticos, equipos de telecomunicaciones, computadoras, etc. Todos estos dispositivos utilizan pantallas fabricadas por terceros de una manera más o menos estandarizada. Cada LCD se compone de una pequeña placa integrada que consta de:

• La propia pantalla LCD. • Un microchip controlador. • Una pequeña memoria que contiene una tabla de caracteres. • Un interfaz de contactos eléctricos, para conexión externa. • Opcionalmente, una luz trasera para iluminar la pantalla.

El controlador simplifica el uso del LCD proporcionando una serie de

funciones básicas que se invocan mediante el interfaz eléctrico, destacando:

• La escritura de caracteres en la pantalla. • El posicionado de un cursor parpadeante, si se desea. • El desplazamiento horizontal de los caracteres de la pantalla

(scrolling).

Figura 11 - LCD


La memoria implementa un mapa de bits para cada carácter de un juego de caracteres, es decir, cada octeto de esta memoria describe los puntitos o píxel que deben iluminarse para representar un carácter en la pantalla. Generalmente, se pueden definir caracteres a medida modificando el contenido de esta memoria. Así, es posible mostrar símbolos que no están originalmente contemplados en el juego de caracteres.

El interfaz de contactos eléctricos suele ser de tipo paralelo, donde

varias señales eléctricas simultáneas indican la función que debe ejecutar el controlador junto con sus parámetros. Por tanto, se requiere cierta sincronización entre estas señales eléctricas.

La luz trasera facilita la lectura de la pantalla LCD en cualquier condición

de iluminación ambiental. Existen dos tipos de pantallas LCD en el mercado: pantallas de texto y

pantallas gráficas.

7.4.2.1. Funcionamiento El funcionamiento de estas pantallas se fundamenta en sustancias que

comparten las propiedades de sólidos y líquidos a la vez. Cuando un rayo de luz atraviesa una partícula de estas sustancias tiene necesariamente que seguir el espacio vacío que hay entre sus moléculas como lo haría atravesar un cristal sólido pero a cada una de estas partículas se le puede aplicar una corriente eléctrica que cambie su polarización dejando pasar a la luz o no.

Una pantalla LCD esta formada por 2 filtros polarizados colocados

perpendicularmente de manera que al aplicar una corriente eléctrica al segundo de ellos dejaremos pasar o no la luz que ha atravesado el primero de ellos. Para conseguir el color es necesario aplicar tres filtros más para cada uno de los colores básicos rojo, verde y azul y para la reproducción de varias tonalidades de color se deben aplicar diferentes niveles de brillo intermedios entre luz y no luz lo, cual consigue con variaciones en el voltaje que se aplicaba los filtros.

7.4.2.2 LCD de texto

Los LCD de texto son los más baratos y simples de utilizar. Solamente

permiten visualizar mensajes cortos de texto. Existen algunos modelos estandarizados en la industria, en función de su tamaño medido en número de líneas y columnas de texto. Existen modelos de una, dos y cuatro filas únicamente. El número de columnas típico es de ocho, dieciséis, veinte y cuarenta caracteres.

7.4.2.3. TFT

TFT o Thin Film Transistor (Transistor de Película Fina) es un tipo

especial de transistor de efecto campo construido depositando finas películas sobre contactos metálicos, capa activa semiconductora y capa dieléctrica.


La aplicación más conocida de los TFT son las pantallas de visualización

planas de LCD, en las cuales cada píxel se controla mediante uno a cuatro transistores. La tecnología de TFT proporciona la mejor resolución de todas las técnicas flat-panel, pero es también la más costosa. Las pantallas de TFT a veces se llaman LCDs de matriz activa.

Opera de forma individual con cada píxel, es decir, es direccionamiento

directo o de matriz activa. esto se consigue mediante una delgada capa de transistores que controlan de forma individual cada píxel obteniendo mejores tiempos de respuesta al no ser necesario el barrido completo de la pantalla ya que el tiempo de de excitación de un píxel es menor que el tiempo de barrido de la pantalla consiguiendo imágenes más nítidas y sin parpadeos.

7.4.3. Pantalla de plasma

Una pantalla de plasma es una pantalla plana en la cual la luz se crea

por la excitación de sustancias fosforecentes mediante una descarga de plasma entre dos pantallas planas de vidrio. La descarga de gas no contiene mercurio (como en la luz de fondo de las pantallas de LCD); una mezcla de gases nobles (neón y xenón) es utilizada en su lugar. Esta mezcla de gas es inerte y totalmente inofensiva.

La pantalla de plasma fue

inventada en la Universidad de Illinois en Urbana-Champaign por Donald L. Bitzer y H. Gene Slottow en 1964 para el sistema informático PLATO. Los paneles originales eran monocromáticos.

Desde 1975, Larry Weber, de la Universidad de Illinois en Urbana-

Champaign, intentó crear una pantalla de plasma de color, consiguiéndolo finalmente en 1995.

El mayor brillo y ángulo de visión de las pantallas de plasma actuales ha

provocado que estas pantallas sean cada vez más populares. El plasma consiste en una sustancia eléctrica neutra con una lata de

ionización compuesta por iones, electrones y partículas neutras. Básicamente el plasma es un mar de electrones e iones que conduce de manera excelente la electricidad. Si se aplica suficiente calor los electrones se separan de sus núcleos.

Figura 12 – Funcionamiento de una pantalla de plasma


Una pantalla de plasma se compone de una matriz de celdas conocidas como píxeles, que se componen a su vez de tres sub-píxeles, que corresponden a los colores rojo, verde y azul.

El gas en estado de plasma reacciona con el fósforo de cada sub-píxel

para producir luz coloreada (roja, verde o azul). Estos fósforos son los mismos que se utilizan en los tubos de rayos catódicos de los televisores y monitores convencionales. Cada sub-píxel está controlado individualmente por un procesador y se pueden producir más de 16 millones de colores diferentes. Imágenes perfectas en un display de profundidad mínima.

7.5. El monitor vs. El ojo

El ojo no es como una cámara de televisión, la cámara produce una

imagen como la superposición de una serie de puntos brillantes y oscuros obtenidos cuando los electrones acelerados por el cañón del televisor a lo largo del tubo que se halla en el interior impactan contra una pantalla de material fluorescente: este material absorbe la energía del choque, se excita y posteriormente se des-excita emitiendo luz... ¡el puntito brillante que vemos!

Para una televisión en color, esos puntos brillantes corresponden cada

uno a un color primario, emitido en función de la energía que ha cedido el electrón acelerado en el choque. Además existe una conexión uno-a-uno entre cada punto del objeto y su imagen final, la cual se mantiene a través del proceso por el que la cámara lo produce. Por lo tanto se puede interrumpir el proceso en cualquiera de sus fases y se puede establecer que esa señal electrónica proviene de ese punto en particular del objeto.

En el cerebro, ¡las cosas son muy distintas! Una parte de la corteza

visual que es la que procesa la señal, puede conectarse a muchas partes diferentes de la retina de modo que el proceso de ver se hace muy complejo. Se cree que ciertas partes de la corteza son muy buenas en el reconocimiento de líneas horizontales y otras lo son en el reconocimiento de las verticales, otras reconocen mejor el contorno de los objetos, etc... Esta compleja arquitectura es la que hace que el cerebro sea mucho mejor en procesar la información visual que incluso el más moderno de los ordenadores, el cual, como una cámara de televisión, trabaja la información sobre la base de uno-a-uno (1:1).

7.6. Profundidad del color

La calidad de la imagen se puede mejorar incrementando la resolución de la pantalla, el número de píxeles del dibujo o también incrementando el número de colores disponibles.

7.6.1. Color de 1-bit

No existe un nombre que se utilice habitualmente para denominar este simple modo de color. La denominación de “blanco y negro” ha sido utilizada


incorrectamente para referirnos a la “escala de grises” cuando en realidad sólo se pueden representar 2 colores.

Este modo de video permite 2 colores ya que se utiliza 1 bit dedicado a

la información de color por cada píxel (21). Cuando hablamos de color de 1 bit nos

referimos a blanco o negro; algunas veces los 2 colores no son blanco y negro, hubo terminales que utilizaron 2 tipos de verdes: claro y oscuro. El siguiente dibujo es un ejemplo de una imagen de 1 bit de profundidad, sólo utiliza el blanco y el negro.

El color de 1-bit se utilizó en dispositivos de texto, hubo excepciones, los Macintosh (que no tenían este modo de texto) y los originales IBM MGA (Monochome Graphics Adapter, que tenía un modo grafico adicional al modo de texto).

7.6.2. Color de 4-bits

Fue utilizado por los dispositivos IBM EGA (Enhanced Graphics Adapter), también por el Commodore 64 y 128 y otros muchos.

BLACK DARK GREY BLUE LIGHT BLUE GREEN LIGHT GREEN CYAN LIGHT CYAN RED LIGHT RED PURPLE LIGHT PURPLE YELLOW LIGHT YELLOW LIGHT GREY

WHITE

Este modo de video permite 16 colores ya que se utilizan 4 bits dedicados a la información de color por cada píxel (24)

El Commodore Amiga e IBM VGA (Vídeo Graphics Adapter) permitían indexación. Sólo se podía disponer de 16 colores de manera simultánea, pero los 16 colores se pueden elegir de una amplia paleta y cada paleta puede redefinir sus colores. Así un programa puede utilizar una escala de 16 grises, los 16 colores originales de EGA, o elegir cualquier combinación de colores de la amplia paleta de colores disponible. La única restricción es la utilización de 16 colores de forma simultánea.

Figura 13 - Imagen con 1 bit de profundidad



Este modo de video permite 256 colores en pantalla ya que se utilizan 8 bits dedicados a la información de color por cada píxel (28). Con estos bits se hace referencia al índice de la paleta de color. La paleta nos permite seleccionar entre 16 millones de colores. Cada color de la paleta se selecciona especificando 8 bits para cada intensidad de rojo, verde y azul (la intensidad de cada componente puede tener una valor entre 0 y 255)

Este modo de color combinado con la fusión permite obtener resultados aceptables para ciertas aplicaciones. También se pueden utilizar los 8 bits para imágenes de un tono continuo en blanco y negro con 256 matices de color, vemos un ejemplo de imagen de tono continuo.


Este modo de video permite 16.777.216 colores en pantalla ya que se utilizan 24 bits dedicados a la información de color por cada píxel (224). Este modo de color mantiene 8 bits de color para componente de color rojo, verde y azul. Disponemos de los más de 16 millones de colores en cada píxel de la pantalla.

Figura 15 - Imagen con 24 bits de profundidad

El inconveniente de la utilización de este modo es la utilización de

memoria que se necesita para pantallas de alta resolución (2MB para 1024x768). También es más lento mover grandes cantidades de memoria para realizar una animación o simplemente dibujar en pantalla. Aunque las tarjetas aceleradoras están optimizadas para este tipo de operaciones.

Figura 14 - Imagen byn con 256 matices de color


7.7. Modelos de color

El propósito de un modelo de color es facilitar la especificación de colores en algún formato estándar. Un modelo de color es una especificación de un modelo de coordenadas 3-D y un subespacio dentro de ese sistema donde cada color se representa por un punto único.

La mayoría de los modelos de color que se utilizan están orientados

hacia el hardware como monitores o impresoras o aplicaciones de manipulación de color. El modelo orientado al hardware más común es el RGB (red-green-blue), el modelo CMY (cyan-magenta-yellow) para impresoras en color y el YIQ que es el estándar para la difusión de TV ( Y = luminancia, I y Q son dos componentes cromáticas). Para la manipulación del color se suelen utilizar los modelos HSI (matiz, saturación e intensidad) y HSV (matiz, saturación y valor).

Los modelos más utilizados en el procesamiento de imágenes son RGB,

YIQ y HSI.

7.7.1. Modelo de color XYZ En los años 30, la Commission Internationale de l'Eclairage (CIE) definió

un espacio de color estándar, una manera de definir colores en términos matemáticos, para facilitar la comunicación de la información de color. Este espacio de color está basado en la investigación sobre la naturaleza de la percepción del color.

7.7.1.1. Espacio de color CIE

En el intento de lograr una representación que utilice solamente

coeficientes de mezcla positivos, el CIE ("d'Eclairage de Internationale de la Comisión") definió tres nuevas fuentes de luz hipotéticas, x, y, y z, resultando curvas positivas:

Figura 16 - representación de las fuentes de luz x, y, z

Dado un espectro y un deseamos encontrar los valores correspondientes de X, de Y, y de Z, lo podemos lograr integrando el producto de la energía


espectral con cada una de las tres curvas sobre todas las longitudes de onda. Los pesos de X, Y y Z se toman del espacio tridimensional del CIE XYZ, según lo mostrado arriba.

Esto es logrado proyectando el espacio de color 3D sobre el plano X+Y+Z=1, resultando un diagrama de la cromaticidad del CIE.

Se define la proyección como:

Resultando el diagrama de cromaticidad CIE

7.7.1.1.1. Diagrama de cromaticidad CIE El diagrama de cromaticidad CIE es un

modelo de dos dimensiones de visión del color. El arco alrededor de la parte superior de la herradura incluye los colores espectrales puros desde el violeta azulado hasta el rojo.

Mezclando dos colores espectrales puros

en diferentes proporciones es posible crear todos los colores que se encuentran en la línea recta dibujada entre ellos en el diagrama. Es posible crear el mismo tono de gris mezclando el verde azulado y el rojo o mezclando el verde

amarillento y el violeta azulado. Esto es posible debido a un fenómeno peculiar de la visión del color llamado metamerismo. Los colores púrpura, que no existen en el espectro de la luz pura, se encuentran en la parte inferior del diagrama. Los púrpuras son mezclas de rojo y azul, los extremos opuestos del espectro.

El diagrama de cromaticidad CIE refleja el tono y la saturación, pero es

necesario un modelo tridimensional para añadir el componente del brillo. Muchas aplicaciones informáticas incluyen cuadros de diálogo en los que es posible seleccionar colores manipulando el tono, la saturación y el brillo. Por ejemplo, Adobe Photoshop utiliza un cuadro Selector de Color que puede configurarse según las preferencias personales.

7.7.1.1.2. Gama de colores

El diagrama de cromaticidad se puede utilizar para comparar las

"gamas" de varios dispositivos de salida posibles (es decir, los monitores e impresoras). Note que una impresora de color no puede reproducir todos los colores visibles en un monitor de color.

Figura 17 - Diagrama de cromaticidad CIE


Figura 18 - Comparación de gamas de colores

7.7.2. El modelo de color RGB

El modelo aditivo de color utilizado para los gráficos de computadora es

representado por el cubo del color del RGB, donde R, G, y B representan los colores producidos por los fósforos rojos, verdes y azules, cubo del color de respectivamente. El cubo se proyecta dentro del espacio de color del CIE XYZ

Nuestros ojos perciben el color a través de la simulación de tres pigmentos visuales en los conos de la retina. Estos pigmentos tienen una sensibilidad pico en las longitudes de onda 630 nm (rojo), 530 nm (verde), y 430 nm (azul). Comparando las intensidades en una fuente de luz, se percibe el color de la luz. Esta teoría es la base para desplegar la salida de color en un monitor de video mediante el uso de los tres colores primarios, conocido como modelo de color RGB.

Cada color aparece en sus componentes primarias espectrales rojo,

verde y azul. El modelo está basado en un sistema de coordenadas cartesiano. El subespacio de interés es el cubo que se muestra en la figura 19.

Todos los colores han sido normalizados de

forma que el cubo es unitario, es decir, se supone que todos los valores de rojo, verde y azul están en el rango [0, 1].

Este esquema de color es un modelo

aditivo : las intensidades de los colores primarios se suman para producir otros colores. Cada punto de color contenido en los límites del cubo puede representarse como la tríada (R,G,B), donde los valores de R,G,B se asignan en el intervalo de 0 a 1. Por ejemplo, el vértice magenta se obtiene sumando el rojo y el azul para producir la tríada (1,0,1) y el blanco en (1,1,1) es la suma de los vértices rojo, verde y azul. Las sombras de gris se representan a lo largo de la diagonal principal del cubo del origen (negro) al vértice blanco. Cada punto situado en esta diagonal tiene una contribución igual de cada color primario, de manera que una sombra de gris en medio del negro y el blanco se representan como (0.5, 0.5, 0.5).

Figura 19 - Cubo RGB


Las imágenes en el modelo de color RGB están formadas por tres planos de imágenes independientes, cada una de los colores primarios. Cuando se introducen en un monitor RGB, las tres imágenes se combinan en la pantalla de fósforo para producir una imagen de color compuesta. Por tanto, se utiliza el modelo RGB para el procesamiento de imágenes si las imágenes se expresan en términos de los tres planos de colores. La mayoría de las cámaras en color que se usan para adquirir imágenes digitales utilizan el formato RGB.

Uno de los mejores ejemplos de la utilidad del modelo RGB es el

procesamiento de imágenes aéreas y de satélites multiespectrales. Estas imágenes se obtienen para diferentes rangos espectrales. Por ejemplo, las imágenes LANDSAT se obtienen como mínimo en cuatro ventanas espectrales distintas de la misma escena. Dos ventanas estarán alojadas en el espectro visible y se corresponden aproximadamente con verde y rojo; las otras dos se encontrarán en el infrarrojo. Así pues cada plano de la imagen tiene sentido físico y la combinación de color utilizando el modelo RGB para procesamiento y visualización tiene sentido cuando se ve en una pantalla en color.

A continuación se muestra una imagen en color de verduras y frutas

junto con sus tres bandas de color rojo, verde y azul. El mayor nivel de gris en cada banda corresponde con el color predominante en cada objeto (fruta o verdura).

Figura 20 - (a) Imagen original en color. (b) Plano de rojo. (c) Plano verde. (d) Plano azul

Sin embargo este modelo de color no siempre es el mejor para el procesamiento de imágenes, por ejemplo para realizar una imagen en color con sombra de una cara humana. Este problema puede resolverse mediante la igualación del histograma. Al tener tres bandas y puesto que el histograma trabaja sólo con las intensidades, cuando igualemos el histograma en cada


banda, en cada una de ellas tendremos mejora, sin embargo, el resultado global, (cuando se combinen las tres bandas), será impredecible.

A pesar de todo este modelo es la elección más corriente para gráficos

por ordenador ya que los CRT usan fósforo rojo, verde y azul para crear el color deseado. Sin embargo, este modelo no describe de forma eficiente las tres componentes de color (R,G,B). El igual ancho de banda da lugar a la misma profundidad del píxel y resolución del dispositivo para cada componente. Sin embargo, la sensibilidad de la componente de color del ojo humano es menor que la de la luminancia.

Por estas razones, muchos métodos de codificación de imágenes y

sistemas de transmisión utilizan la luminancia y dos diferencias de colores. Estos son los formatos YUV, YIQ, Y CbCr.

7.7.3. El modelo de color CMY (Cyan, Magenta, Amarillo)

Un modelo de color definido con los colores primarios cyan, magenta y

amarillo (CMY) es útil para describir la salida de color de los dispositivos de copia hardware. A diferencia de los monitores de video, que producen un modelo de color combinando luz de los fósforos de la pantalla, los dispositivos hardware como las impresoras producen una imagen de color cubriendo un papel con pigmentos de color. Se obtienen los colores por luz reflejada, lo cual es un proceso sustractivo.

Por ejemplo, el cyan (azul-verde) puede formase combinando luz verde

con luz azul, por tanto cuando se refleja luz blanca sobre un objeto que es verde-azul la luz reflejada no debe tener componente roja, es decir, la luz roja es absorbida, o sustraída por el objeto. De forma análoga para obtener el magenta se resta la componente verde de la luz incidente y el amarillo sustrae la componente azul.

En el modelo CMY, el

punto (1,1,1) representa el negro, ya que todas las componentes de la luz incidente se sustraen. El origen representa la luz blanca. Cantidades iguales de cada uno de los colores primarios producen grises a lo largo de la diagonal principal del cubo.

Como ya sabemos el cyan, magenta y amarillo son los colores

secundarios. Para convertir los colores primarios en secundarios hemos de realizar la siguiente transformación:

Cyan (Verde-Azul)

Azul

Magenta

Rojo

Amarillo Verde

Blanco

Negro

Figura 21 - Cubo de Color


⋅

=

B

G

R

Y

M

C

1

1

1

La figura 20 (a,b,c) muestra las representaciones en las

correspondientes bandas de la imagen en la figura 20 (a). Para obtener estas imágenes se ha normalizado cada canal a uno independientemente, dividiéndolo por 255, a continuación se le ha restado a uno dicha cantidad y por último se ha multiplicado el resultado por 255.

7.7.4. El modelo de color YUV

Este es el formato de color que se utiliza por los estándares de TV

NTSC, PAL y SECAM. La Y representa la componente de blanco y negro y la información de color U y V se añade para mostrar una imagen en color. La transformación es:

−

−−−−=

B

G

R

V

U

Y

100.0515.0615.0

436.0289.0147.0

114.0587.0299.0

Observemos que U = 0.492 (B - Y). y que V = 0.877 (R – Y ).

Normalmente U y V son submuestreados por un factor de dos a cuatro en la dimensión espacial, ya que el ojo humano es mucho menos sensible a estos factores. Esto es muy útil, por ejemplo, para reducir el número de bits utilizado en técnicas de compresión de imágenes.

7.7.5. El modelo de color YIQ

Este modelo se utiliza en las emisiones de TV en color. Básicamente,

YIQ es una recodificación de RGB para aumentar la eficiencia en la trasmisión y para mantener la compatibilidad con los estándares de TV monocromo. De hecho, la componente Y del sistema YIQ proporciona toda la información de video que se requiere para una televisión monocromo. La conversión de RGB a YIQ viene dada por:

•

−−−=

B

G

R

Q

I

Y

311.0523.0212.0

321.0275.0596.0

114.0587.0299.0

Este sistema fue diseñado teniendo en cuenta las características del

sistema visual humano, obteniendo mayor sensibilidad a los cambios en luminancia que a los cambios de matiz o saturación. Así pues, este estándar usa más bits (o ancho de banda) para representar Y y menos para I y Q.

Es uno de los modelos que más se utilizan. Una de sus mayores

ventajas es que las informaciones de luminancia (Y) y color (I y Q) están separadas, esto nos permite procesar la luminancia sin afectar al color.


La figura 22 (d,e,f) muestra las representaciones en las correspondientes bandas de la imagen en la figura 22 (a).

Figura 22 - (a) Plano C del modelo CMY (b) Plano M del modelo CMY (c) Plano

Y del modelo CMY (d) Plano Y del modelo YIQ (e) Plano I del modelo YIQ (f) Plano Q del modelo YIQ.

Observemos que la figura 22(d) es una imagen en niveles de gris de la imagen original. Puesto que las bandas YUV tienen rangos distintos todas han sido llevadas al [0,255] para la visualización. Tengamos en cuenta que tanto la banda U como V pueden tener valores negativos.

7.7.6. El modelo de color HSI El matiz es un atributo que describe la pureza de un color. La saturación

es una medida del grado en el que un color puro se diluye con la luz blanca. La utilidad del modelo de color HSI se debe principalmente a estas dos características:

- La componente de intensidad se separa de la información de color - Las otras dos componentes están muy relacionadas con la forma en

la que el ser humano percibe el color. Gracias a estas propiedades este modelo es muy apropiado para el

desarrollo de algoritmos de procesamiento de imágenes basados en propiedades del sistema de visión humano.


7.7.7. El sistema HLS (Hue, Saturation and Luminance) Este modelo utiliza los tres componentes básicos del color: matiz (Hue),

saturación (Saturation) y brillo (Luminance). Una representación gráfica incluyendo estas tres propiedades genera el denominado "espacio y color".

En el perímetro del disco están situados

los colores azul, magenta, rojo, amarillo, verde y cyan, separados 60º uno de otro:

Cada punto del perímetro describe un

color que es mezcla de los dos adyacentes. Un punto que no esté en el perímetro contendrá una mezcla de todos. Por lo tanto, estos puntos describen colores pastel que contienen una cierta cantidad de blanco. La distancia al centro (radio) indicará la saturación del color. El brillo (intensidad del color) depende de la altura en el doble cono, y es un valor entre 0 y 1.

El punto medio del disco central

describe un blanco de intensidad media. Supongamos que, por ejemplo, comenzamos en el perímetro del cono en el ángulo cero (color azul) y nos movemos en línea recta hacia arriba: estamos añadiendo más blanco, por lo que pasaremos por un azul claro, un azul pastel casi blanco hasta llegar finalmente a un blanco brillante. Esto sucede con todos los colores.

La conclusión es que todos los colores convergen al blanco a medida

que avanzamos hacia el vértice superior y hacia el negro a medida que bajamos.

7.7.8. Modelo HSV

Fue creado a partir de un concepto intuitivo de la manera de trabajar de

un artista y su modo de mezclar colores para obtener el correcto sombreado y la obtención de los tonos intermedios. La selección y obtención de colores en el modelo HSV es mucho más intuitiva que en los modelos RGB y CMY. Se basa principalmente en el control de los valores de matiz, saturación y valor (HSV).

− Hue (Matiz): Se representa en un ángulo en torno a un eje vertical

(0º...360º). Los vértices del hexágono se separaran a intervalos de 60º. El rojo está en 0º, el amarillo en 60º, el verde en 120º y el azul-verde opuesto al rojo en H = 180º. Los colores complementarios distan 180º.

Figura 23 - Modelo HLS


− Saturation (Saturación): Varia

de 0 a 1. Representa la pureza de un matiz. La pureza máxima se representa en S = 1. En S = 0 se tiene la escala de gris.

− Value (Valor): Varia de 0 en la

cúspide del cono hexagonal a 1 en la parte superior. En la cúspide se encuentra el negro, en la parte superior los colores de máxima intensidad.

Los conceptos de color

asociados con los términos sombras, tintes y tonos se representan en un plano seccional-transversal del cono hexagonal HSV. Si se agrega negro a un matiz puro se disminuye V hacia el lado del cono hexagonal. Por lo tanto, varias sombras se representan con valores S=1 y 0<= V <= 1. Si se agrega blanco a un tono puro se producen diferentes tintes a través del plano superior del cono hexagonal, donde los valores de los parámetros son V = 1 y 0 <= S <= 1. Diversos tonos se especifican agregando blanco y negro, produciendo puntos de color dentro del área seccional-transversal triangular del cono hexagonal. Cuando V= 1 y S = 1 se tienen los matices “puros”. El blanco se obtiene en S = 0 y V = 1.

Figura 24 - Modelo HSV


7.8. Colores en OpenGL

7.8.1. Utilización de colores con OpenGL

OpenGL especifica un color utilizando las intensidades separadas de

componentes rojo, verde y azul. Por lo tanto un color se especifica con 3 valores positivos, y puesto que el máximo disponible en el PC para el almacenamiento de esta información son 24 bits (8 bits para cada componente) podemos modelar los colores disponibles mediante un cubo de 255 unidades en cada cara. A este volumen lo denominamos el espacio de color RGB.

Este “cubo de color” contiene todos los colores que podremos utilizar en

nuestras aplicaciones, tanto en la superficie como en el interior del mismo. El modelo de color RGBA es el que utilizamos cuando definimos un color

con la función glColor*; utilizamos el modelo de color indexado cuando seleccionamos un color de dibujo indicando un índice en una matriz de colores disponible llamada paleta. Dentro de esta paleta, especificamos el color exacto que queremos seleccionando las intensidades de las componentes roja, verde y azul.

Los elementos geométricos se dibujan con los atributos activos en cada

momento. En cualquier momento se pude modificar el valor de los atributos, sustituyendo el nuevo valor al anterior. Los atributos podrán apilarse y desapilarse.

La figura siguiente muestra el dibujo simple de dos triángulos de diferentes colores. Estos se definen con la instrucción glColor3f(red,green,blue) tal como se muestra en el código C (ver código completo en el anexo, ejemplo 1).

void triangulo1(void)

{

glBegin(GL_TRIANGLES);

glColor3f(1.0,0.0,0.0);

glVertex2f(0.0,0.4);

glVertex2f(-0.4,0.0);


glEnd();

}

void triangulo2(void)

{

glBegin(GL_TRIANGLES);

glColor3f(0.0,0.0,1.0);

glColor3f(0.0,1.0,0.0);

glVertex2f(0.0,-0.4);

glVertex2f(-0.4,0.2);


glEnd();

}

Figura 25 - Triángulos


Listado 1 - Ejemplo de definición de colores

A pesar de que existe una instrucción que establece el color del segundo triángulo a azul, ésta no tendrá efecto ya que quedará anulado por la siguiente instrucción que lo pone a verde.

La sintaxis de la función glColor es la siguiente:

Al dibujar polígonos se puede controlar que se dibujen sus aristas o solo el interior. Es normal dibujar las aristas al realizar esquemas, mientras que estas se suelen suprimir cuando se desea general imágenes realistas. El control de visibilidad de las aristas se realiza con la función glEdgeflag(b) donde el argumento b será 0 o 1 dependiendo de que se active o no el dibujo de las aristas.

Pero no sólo podemos conseguir colores solidos, también gradientes. Eso

lo podemos llevar a la con un triángulo, por ejemplo; bastará con que le asignemos un color distinto a cada vértice para que OpenGL rendere la imagen con el gradiente de color resultante entre ellos (fijémonos que estamos con lo que se denomina, color suave). La construcción del triángulo quedará así:

• Propósito: Selecciona el color actual en el modo de color RGBA. • Fichero de inclusión: <gl.h> • Sintaxis: void glColor<numero args><tipo args>. Donde número de argumentos puede ser 3 ó 4 (si hay componente alfa), y tipo de argumentos puede ser b(byte), d(double), f(float), etc.. Por ejemplo: void glColor4b( GLbyte rojo, GLbyte verde, GLbyte azul, GLbyte alfa); o void glColor3fv(const GLfloat *v); • Descripción: Selecciona el color activo especificando por separado las componentes roja, verde y azul. Algunas aceptan también la componente alfa (si no se especifica vale por defecto 1.0). Las funciones con sufijo v toman un puntero a una matriz que especifica las componentes. • Parámetros: rojo Especifica la componente roja del color. verde Especifica la componente verde del color. azul Especifica la componente azul del color. alfa Especifica la componente alfa del color. (Ver siguiente apartado) *v


glBegin GL_TRIANGLES glColor3f( 1.0,0.0,0.0 ) //color rojo glVertex3f( 0.0,1.0,0.0 ) glColor3f( 0.0,1.0,0.0 ) //color verde glVertex3f( -1.0,-1.0,0.0 ) glColor3f( 0.0,0.0,1.0 ) //color azul glVertex3f( 1.0,-1.0,0.0 )

glEnd

Listado 2 - Ejemplo de definición de un gradiente

El resultado de la coloración de la escena es la siguiente:

Figura 26 - Gradiente

7.8.2. Modelo de color RGBA

En el modelo RGBA utilizamos la función glColor*( ) para seleccionar el color actual que establece los colores rojo, verde, azul y la componente alfa (si se utiliza transparencia). Todos los objetos dibujados después de la aplicación de esta función tendrán el último color especificado en la misma.

Canal alpha

El canal alpha no es más que una imagen de 8 bits en escala de grises. OpenGL interpreta esta información como sigue:

• Un valor alpha de 0 (color negro) indica transparencia total, es decir, que la zona del polígono afectada por este valor no se verá. • Un valor de 128 (color gris "puro") indica semitransparencia. • Un valor de 255 (color blanco) indica opacidad total El funcionamiento es el siguiente: El modelo RGBA de color dota a cada punto de una cuarta componente

llamada canal alfa. Este sirve para decidir que debe hacerse con ese punto si contribuye junto con otros a colorear un píxel. Hasta ahora el citado píxel se


pintaría del color del polígono más cercano pero si activamos el canal alfa obtendremos “mezclas de colores” para el píxel. Cada polígono contribuirá en un cierto tanto por ciento a colorear el píxel de forma que podemos obtener interesantes efectos como emular un cristal tintado o un papel de celofán rojo, por ejemplo:

En esta imagen se observa que

mezclando dos colores generamos un tercero o lo que es lo mismo, que si tengo un objeto de color rojo y le pongo delante un papel translúcido de color azul, la intersección de ambos se verá de color lila.

Eso ocurre porque el polígono que

está más cerca tiene un cierto grado de transparencia por lo cuál nos deja ver lo que tiene detrás. A esto se le llama “Blending”. Siempre se habla de una

fuente (source) y un destino (destination). El destino es el valor de color que un píxel ya tiene asignado en el frame buffer. La fuente es el color que viene, el color que se mezclará con el que ya tiene.

Se combinan los colores de la fuente y del destino según el valor de

alfa que tiene cada uno de ellos. Se define una función de mezclado, o de “blending” que, según sea, aplicará de una forma o de otra el canal alfa de cada color.

Para hacer esto con OpenGL se deberá activar el mezclado de

colores y desactivarlo con las funciones glEnable(GL_BLEND) y glDisable(GL_BLEND) .

Para indicar como debe hacerse la mezcla se usará la función

glBlendFunc(Glenum factorfuente, Glenum factordesti no) . Dos ejemplos:

1. glBlendFunc(GL_ONE,GL_ZERO). En este caso estamos dando una importancia de 1 (máxima) al canal alfa de la fuente y de 0 (nula) al canal alfa del destino. Eso equivale a decir que el color final se compone de un 100% del de la fuente y de un 0% del color destino por lo cual el píxel acaba siendo del color de la fuente. 2. glBlendFunc(GL_SRC_ALPHA, GL_ONE). En este caso le decimos que multiplique a la fuente por su valor de alfa y sume el resultado al color destino. En este caso y asumiendo un valor de alfa igual a 0.75 para la fuente, podríamos decir que el color resultante=(color de la fuente*0.75)+Color del destino.

Sintaxis de la funcion: glBlendFunc(Glenumfactor_o,Glenumfactor_d) :

Figura 27 - Funcionamiento canal alpha


• Propósito: Define el color de las funciones de mezcla. • Fichero de inclusión: <GL/gl.h> • Sintaxis: void glBlendFunc( GLenum factor_o, GLenum factor_d); • Descripción: Selecciona los factores de origen y destino para la mezcla de colores. Primero debemos llamar a glEnable(GL_BLEND) para activar la mezcla de colores. • Parámetros: factor_o GLenum: la función de mezcla de color en origen. factor_d GLenum: la función de mezcla de color en destino. • Retornos: Ninguno


Para las funciones glColor que aceptan valores enteros el rango de valores que se acepta varía entre 0.0 y 1.0. el máximo y el mínimo valor que puede ser almacenado en el framebuffer.

Cuando se especifican las componentes de color utilizando enteros sin

signo, estas componentes son mapeadas linealmente a valores de coma flotante, de manera que representen valores comprendidos entre el 1.0 (intensidad total) y 0.0 (intensidad nula). Las componentes especificadas utilizando valores enteros con signo son mapeadas linealmente a valores de coma flotante, de manera que el valor más positivos representa al 1.0 y el más negativo al 0.0

Sufijo Tipo de Dato Valor mínimo mínimo Valor de

Mapeo

Valor

Máximo

Valor Máximo de

Mapeo

B 1-byte-integer -128 -1.0 127 1.0

S 2-byte-integer -32768 -1.0 32767 1.0

I 4-byte-integer -

2.147.483.648

-1.0 2.147.483.647 1.0

Ub Unsigned 1- byte-

integer

0 0.0 255 1.0

Us Unsigned 2- byte-

integer

0 0.0 65535 1.0

Ui Unsigned 4- byte-

integer

0 0.0 4.294.967.295 1.0

Una de las primeras acciones que hay que realizar en nuestras aplicaciones es limpiar el área de dibujo en la que vamos a trabajar.

• Propósito: Selecciona los valores de color y alfa para borrar los buffers de color. • Fichero de inclusión: <gl.h> • Sintaxis: void glClearColor(GLclampf rojo, GLclampf verde, GLclampf azul, GLclampf alfa); • Descripción: Selecciona los valores de relleno para borrar los buffers rojo, verde, azul y alfa, que varían entre [0.0f,1.0f]. • Parámetros: rojo GLclampf: la componente roja del valor de relleno. verde GLclampf: la componente verde del valor de relleno. azul GLclampf: la componente azul del valor de relleno. alfa GLclampf: la componente alfa del valor de relleno. • Retornos: Ninguno.


Limpiaremos la ventana cada vez que dibujemos una nueva imagen. Utilizando el modelo tetradimensional RGBA podemos crear efectos en la ventana de dibujo que interactúa con otras ventanas que se encuentren debajo de ella, manipulando la opacidad de la ventana al limpiarla.

La función glClearColor(GLclampf rojo, GLclampf verde, GLclampf azul,

GLclampf alfa) selecciona los valores de relleno para borrar los buffers rojo, verde, azul y alfa, que varían entre [0.0f,1.0f]. Su sintaxis es la siguiente:

La figura muestra un ejemplo de modelo de color RGBA en el que se muestra la transparencia de un cristal de color rojo que deja ver parte de la esfera verde situada por detrás de él. El código correspondiente a la misma es el siguiente:

Figura 28 – modelo de color RGBA


#include <windows.h> #include <GL/gl.h> #include <GL/glut.h> #include <math.h> int idventana; void cristal(void) { glShadeModel(GL_FLAT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glPushMatrix(); glTranslatef(-10,-10,-100.0); glBegin(GL_QUADS);//Dibuja el cristal glColor4f(1.0,0.0,0.0,0.10); glVertex3f(0,0,0); glVertex3f(0,10,0); glVertex3f(10,10,0); glVertex3f(10,0,0); glEnd(); glPopMatrix(); glDisable(GL_BLEND); } void bola(void) { glPushMatrix(); glTranslatef(0,0,-150); glColor4f(0.0,0.8,0.0,1.0);//Dibuja la bola amaril la glutSolidSphere(6,20,10); glPopMatrix(); } void display(void) { GLfloat pos[4]={2.0,12.0,3.0,0.0}; glClearColor(1,1,1,1); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); bola(); cristal(); glutSwapBuffers(); glFlush(); } void myReshape(GLsizei w, GLsizei h) { glViewport(0,0,w,h); glMatrixMode(GL_PROJECTION);


glLoadIdentity(); if (h==0) gluPerspective(20,(GLdouble)w,1.0,500.0); else gluPerspective(20,(GLdouble)w/(GLdouble)h,1.0,500. 0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glFlush(); } void Idle(void) { angulo+=0.5; if (angulo>360) angulo=0; glutPostRedisplay(); } int main(int argc, char **argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEP TH); glutInitWindowPosition(0,0); glutInitWindowSize(300,300); idventana=glutCreateWindow("Transparencia"); glutReshapeFunc(myReshape); glutDisplayFunc(display); glutIdleFunc(Idle); glutMainLoop(); return 0; }

Listado 3 - Ejemplo de definición de transparencia

7.8.3. Modelo de color indexado

Muchos sistemas tienen frame buffer limitado en profundidad. Podemos tener una resolución espacial para el frame buffer de 1280x1024, pero cada píxel tendría solo 8 bits de profundidad. Podemos dividir estos 8 bits en grupos más pequeños de bits para asignar rojo, verde y azul. En algunas aplicaciones esta técnica puede ser adecuada, pero no es muy flexible en la asignación de colores ya que divide los bytes en distintos grupos de bits que pueden afectar al resultado.


Podemos seleccionar los colores interpretando nuestra limitación de profundidad (en los píxeles) como índices mejor que como valores de color. Estos índices corresponden a filas o entradas en una tabla. Suponiendo que nuestro frame buffer tiene k bits por píxel. Cada valor de píxel o índice es un entero entre 0 y 2 k-1. Si podemos mostrar colores con una precisión de m bits podremos elegir entre 2m rojos, 2m verdes y 2m azules. Produciremos cualquiera de los 23m colores aunque el frame buffer solo pueda especificar 2k colores. Utilizamos una tabla de búsqueda de colores de tamaño 2k * 3m, el programa del usuario considerará 2 k filas de la tabla con los colores deseados utilizando m bits para cada rojo, verde y azul.

Una vez que el usuario ha construido la tabla puede especificar un color

por su índice que apunta a la posición adecuada en la tabla de búsqueda de color. Para k=m=8, una configuración muy común, se pueden elegir 256 colores de entre 16 millones de colores. Las 256 entradas en la tabla constituyen la paleta de color del usuario.

Entrada Rojo Verde Azul

0 0 0 0

1 2m-1 0 0

. 0 2m-1 0

. . . .

. . . .

2k -1 . . .

m bits m bits m bits

Si estamos utilizando el modelo de color indexado, el color actual es seleccionado llamando a la función:

void glIndex{sifd ub} (TYPE c ); void glIndex{sifd ub}v (const TYPE *c ); Sintaxis de la función glIndex:


En el modelo RGBA vimos la especificación de glClearColor(), para el

modelo de color indexado existe su análogo que es glClearIndex().

Formato de la instrucción glClearIndex :

Para especificar el modo indexado de color debemos seleccionar el miembro iPixelType de la estructura PIXELFORMATDESCRIPTOR como se muestra a continuación:

• Propósito: Selecciona el índice de color actual para usar con las operaciones de color. • Fichero de inclusión: <gl.h> • Sintaxis: • void glIndexd( GLdouble c); • void glIndexf( GLfloat c); • void glIndexi( GLint c); • void glIndexs( GLshort c); • void glIndexdv( const GLdouble *c); • void glIndexfv( const GLfloat*c); • void glIndexiv( const GLint *c); void glIndexsv( const GLshort *c); • Descripción: Esta función cambia el índice de color actual al especificado por c. • Parámetros: c El índice del nuevo color para uso en las siguientes operaciones. *c Un puntero al índice del nuevo color para uso en las siguientes operaciones. • Retornos: Ninguno.

• Propósito: Especifica un índice de color para el buffer de color. • Fichero de inclusión: <GL/gl.h> • Sintaxis: void glClearIndex(GLfloat indice); • Descripción: Selecciona el valor de color que usaremos para borrar el buffer de color con glClear(GL_COLOR_BUFFER_BIT). • Parámetros: índice GLfloat: el índice de color para el buffer de color. • Retornos: Ninguno.


PIXELFORMATDESCRIPTOR pfd; //declaración estructura pfd.iPixelType = PFD_TYPE_COLORINDEX; //Selección modo

indexado de color Si por el contrario trabajamos con el modo RGBA de color

seleccionaremos el miembro iPixelType de la estructura PIXELFORMATDESCRIPTOR de esta manera:

pfd.iPixelType = PFD_TYPE_RGBA; //Selección

modo RGBA de color

Pegar código paleta.c

/////////////////////////////////////////////////// //

// Principal o punto de entrada para todos los

programas Windows

/////////////////////////////////////////////////// //

int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTA NCE

hPreviousInst,

LPSTR lpszCmdLine, int nCmdShow)

{

HGLRC hRC; // Contexto para OpenGL

HWND hWnd; // Almacenamiento

para la gestion de Ventana

MSG msg; // Estructura de

mensajes de Windows

DWORD buffer = PFD_DOUBLEBUFFER; // tipo de

buffer

BYTE color = PFD_TYPE_RGBA; // tipo de

color

// Si en la llamada a la aplicación se ha

incluido el parámetro -sb

if (strstr(lpszCmdLine, "-sb")) { // Modo RGB

buffer = 0;

}



incluido el parámetro -ci

if (strstr(lpszCmdLine, "-ci")) {

color = PFD_TYPE_COLORINDEX; // Modo de

color Indexado

}


incluido el parámetro -h

if (strstr(lpszCmdLine, "-h")) {

//Mostramos ayuda

MessageBox(NULL, "paleta [-ci] [-sb]\n"

" -sb single buffered\n"

" -ci color index\n",

"Usage help", MB_ICONINFORMATION);

exit(0); //saliendo!!

}

// Crea la ventana principal de la aplicación con

el tipo

// y buffer de color seleccionado

hWnd = CreateOpenGLWindow("paleta", 0, 0, 256,

256, color, buffer);

if (hWnd == NULL)

// Si no se puede crear correctamente

salimos del programa!!

exit(1);

// Almacena el contexto de dispositivo

hDC = GetDC(hWnd);

// Crea el contexto de generación y lo activa

hRC = wglCreateContext(hDC);

wglMakeCurrent(hDC, hRC);

// Visualiza la ventana

ShowWindow(hWnd, SW_SHOW);


UpdateWindow(hWnd);

while (1) //bucle infinito!!

{

// Procesa los mensajes de la aplicación

hasta que

// la aplicación se cierra

while(PeekMessage(&msg, hWnd, 0, 0,

PM_NOREMOVE)) {

if(GetMessage(&msg, hWnd, 0, 0))

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

else

{

goto quit; //solicitada salida del

programa

}

}

// Le hace de todo al triangulo (lo dibuja,

rota, colorea, ...)

triangulo();

}

//Solicitan salir del programa

quit:

// Deselecciona el contexto de generación

activado

wglMakeCurrent(NULL, NULL);

ReleaseDC(hDC, hWnd);

wglDeleteContext(hRC);

//destruye la ventana window!

DestroyWindow(hWnd);


// Borra la paleta si fue creada

if (hPalette)

DeleteObject(hPalette);

return 0;

}

/////////////////////////////////////////////////// //

// Creacion de la ventana para la aplicación

/////////////////////////////////////////////////// //

HWND CreateOpenGLWindow(char* title, int x, int y, int

width, int height,

BYTE type, DWORD flags)

{

int n, pf;

HWND hWnd; //

Almacenamiento para la gestion de Ventana

WNDCLASS wc; // Estructura de

clase de Windows

LOGPALETTE* lpPal; // Puntero a

memoria para la paleta logica

PIXELFORMATDESCRIPTOR pfd; // Descriptor

del formato de pixel

static HINSTANCE hInstance = 0; // Instancia de

almacenamiento

// Tan solo registro la clase de la ventana una

vez

// uso hInstance como un flag

if (!hInstance) {

hInstance = GetModuleHandle(NULL);

// Registra el estilo de la Ventana

wc.style = CS_OWNDC;


wc.lpfnWndProc = (WNDPROC)WindowProc;

wc.cbClsExtra = 0;

wc.cbWndExtra = 0;

wc.hInstance = hInstance;

wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);

wc.hCursor = LoadCursor(NULL, IDC_ARROW);

// No se necesita para la brocha de fondo de la

ventana OpenGL

wc.hbrBackground = NULL;

wc.lpszMenuName = NULL;

wc.lpszClassName = "OpenGL";

// Registra la clase de la ventana

if (!RegisterClass(&wc)) {

MessageBox(NULL, "RegisterClass() failed: "

"No puedo registrar la class

Window.", "Error", MB_OK);

return NULL;

}

}

// Crea la ventana principal de la aplicación

hWnd = CreateWindow("OpenGL", title,

WS_OVERLAPPEDWINDOW |

WS_CLIPSIBLINGS | WS_CLIPCHILDREN,

x, y, width, height, NULL, NULL,

hInstance, NULL);

// Si no se puede crear la ventana principal

mostramos error!

if (hWnd == NULL) {

MessageBox(NULL, "CreateWindow() failed: No

puedo crear la ventana.","Error", MB_OK);

return NULL;


}

hDC = GetDC(hWnd);

// No hay garantías de que el contenido de la

pila que comienza en

// pfd este a 0, nos aseguramos de ello

memset(&pfd, 0, sizeof(pfd));

pfd.nSize = sizeof(pfd); // Tamaño de

la estructura

pfd.nVersion = 1; // Version de

esta estructura

// Dibuja

en la ventana (No en el mapa de bits), // Soporta l lamada

OpenGL en la ventana, flags

pfd.dwFlags = PFD_DRAW_TO_WINDOW |

PFD_SUPPORT_OPENGL | flags;

pfd.iPixelType = type; // Tipo de pixel

pfd.cColorBits = 32; // Tamaño del

Buffer de Profundidad

// Escoge el formato de pixel que mejor encaje en

lo descrito por pfd

pf = ChoosePixelFormat(hDC, &pfd);

if (pf == 0) {

MessageBox(NULL, "ChoosePixelFormat() failed: "

"No encuentro un formato de píxel que se

ajuste!.", "Error", MB_OK);

return 0;

}

// Selecciona el formato de píxel para el

contexto de dispositivo

if (SetPixelFormat(hDC, pf, &pfd) == FALSE)

{


MessageBox(NULL, "SetPixelFormat() failed:

"

"No encuentro el formato especificado.",

"Error", MB_OK);

return 0;

}

//Toma el formato de píxel y recupera la

descripcion del formato de píxel

DescribePixelFormat(hDC, pf,

sizeof(PIXELFORMATDESCRIPTOR), &pfd);

/* Si el tipo de píxel seleccionado es Index ó se

necesita una paleta

entonces realiza selecciona una paleta con las

entradas especificadas*/

if (pfd.dwFlags & PFD_NEED_PALETTE ||

pfd.iPixelType == PFD_TYPE_COLORINDEX) {

n = 1 << pfd.cColorBits;

if (n > 256) n = 256;

lpPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +

sizeof(PALETTEENTRY) * n);

memset(lpPal, 0, sizeof(LOGPALETTE) +

sizeof(PALETTEENTRY) * n);

lpPal->palVersion = 0x300;

lpPal->palNumEntries = n;

GetSystemPaletteEntries(hDC, 0, n, &lpPal-

>palPalEntry[0]);

/* Si el tipo de píxel seleccionado es RGBA,

entonces realiza selección


de las mascaras para RGB, si por el contrario

se selecciona Indexado

hay que elegir los elementos de forma

individual 1 a 1 */

if (pfd.iPixelType == PFD_TYPE_RGBA) {

int redMask = (1 << pfd.cRedBits) - 1;

int greenMask = (1 << pfd.cGreenBits) - 1;

int blueMask = (1 << pfd.cBlueBits) - 1;

int i;

/* Rellena las entradas con los colores

necesarios para el RGB */

for (i = 0; i < n; ++i) {

lpPal->palPalEntry[i].peRed =

(((i >> pfd.cRedShift) & redMask) *

255) / redMask;

lpPal->palPalEntry[i].peGreen =

(((i >> pfd.cGreenShift) & greenMask) *

255) / greenMask;

lpPal->palPalEntry[i].peBlue =

(((i >> pfd.cBlueShift) & blueMask) *

255) / blueMask;

lpPal->palPalEntry[i].peFlags = 0;

}

}

else

{

/* Rellena las entradas con los colores

necesarios para el Index */

lpPal->palPalEntry[0].peRed = 0;

lpPal->palPalEntry[0].peGreen = 0;

lpPal->palPalEntry[0].peBlue = 0;

lpPal->palPalEntry[0].peFlags =

PC_NOCOLLAPSE;






PC_NOCOLLAPSE;





PC_NOCOLLAPSE;





PC_NOCOLLAPSE;

}

//Crea la paleta

hPalette = CreatePalette(lpPal);

if (hPalette) {

//Avanza, selecciona y realiza la paleta

para este contexto de dispositivo

SelectPalette(hDC, hPalette, FALSE);

RealizePalette(hDC);

}

//libera la memoria de la estructura lpPal

free(lpPal);

}

ReleaseDC(hDC, hWnd);

return hWnd;

}

Listado 4 - Color indexado vs. Color RGBA


Figura 29 - Paleta modelo de color RGB

Figura 30 - Paleta modelo de color Index

7.8.4. Modelo de color RGBA vs. Modelo de color Indexado

No podemos usar el modo de color indexado y el modo de color RGBA juntos. Esto significa que si usamos el modo indexado en un dispositivo de color real, no tendremos acceso a todos los colores disponibles. Bajo algunas implementaciones, la paleta de color indexado puede tener hasta 4096 entradas; sin embargo, la implementación de Microsoft sólo soporta 256 entradas.

Además de limitar la selección de colores, el modo indexado de color no

soporta otros efectos especiales de OpenGL, incluidos muchos efectos de iluminación y sombreado, niebla, anti-escalonado y mezcla alfa. Generalmente es mejor usar el modo RGBA. La ventaja más significativa de usar el indexado es un mayor control de la paleta en dispositivos de pantalla de 8 bits.

Nuestra decisión en la utilización de modelo de color RGBA o Indexado

puede basarse en el hardware disponible y en las necesidades de nuestra aplicación. Para la mayoría de sistemas muchos colores pueden ser representados simultáneamente tanto con el modelo de color RGBA como con el modelo de color Indexado. Sin embargo, en muchos efectos como el sombreado, la iluminación, mapeado de texturas y niebla, el modelo RGBA proporciona una mayor flexibilidad que el modelo de color indexado.

Podemos optar por utilizar el modelo de color indexado en tres casos:

1. Si estamos migrando una aplicación que hace un uso importante del modelo de color indexado es más sencillo no cambiarlo al modelo RGBA.


2. Si disponemos de un pequeño numero de planos de color el modelo RGBA puede producir sombreados de color de baja calidad. Por ejemplo, si sólo disponemos de 8 planos de color con el modelo RGBA sólo dispondremos de 3 bits para el rojo, 3 bits para el verde y 2 para el azul, es decir, 8 (23) sombras de rojo y verde, y sólo 4 de azul. En esta situación si tenemos limitados los requerimientos de sombreado podemos utilizar una tabla de búsqueda de color para obtener mas colores de sombra. Por ejemplo, si requerimos sólo sombras azules se puede utilizar el modelo de color indexado y almacenar 256 (28) sombras de color azul, esto es mucho mejor que las 4 sombras que nos ofrecía el modelo de color RGBA. 3. El modelo de color indexado puede ser utilizado para hacer varios trucos, como mapas de color, animaciones y dibujo por capas.

En general, utilizaremos el modelo de color RGBA siempre que sea

posible ya que permite mapeado de texturas y trabaja mejor con sombreado, iluminación, niebla, antialiasing y combinación de colores (blending).

7.8.5. Ocultaciones

OpenGL permite utilizar dos métodos de ocultación: el algoritmo de las caras de detrás (Back Face Removal), y el algoritmo del Z-buffer.

7.8.5.1. Algoritmo de las caras de detrás

Consiste en ocultar las caras que no se dibujarían porque formarían parte de la parte trasera del objeto. Para decirle a OpenGL que queremos activar este método de ocultación, tenemos que escribir:

glEnable(GL_CULL_FACE)


Figura 31 - Sin ocultaciones

Figura 32 - Ocultando caras de detrás Importante. OpenGL ignora totalmente la normal que le podamos pasar

con la función glNormalf , así que esta normal sólo se utiliza a efectos de iluminación. A efectos de ocultación de caras, OpenGL decide si oculta o no una cara a partir del orden de definición de los vértices que la forman.

Así, si la proyección sobre del camino que forman los vértices del

primero al último es en el sentido de las agujas del reloj, entonces se dice que el orden es clockwise . Si es en sentido inverso, se dice que es counterclockwise . Por defecto, OpenGL sólo renderiza aquellos polígonos cuyos vértices estan en orden counterclockwise cuando son proyectados sobre la ventana. Pero los objetos definidos por la GLUT no tienen porqué estar definidos clockwise (como es el caso de la tetera). Por tanto, antes de renderizarlos usando este algoritmo de ocultación, debemos llamar a glFrontFace(GL_CW) o a glFrontFace(GL_CCW).

7.8.5.2 Algoritmo del Z-buffer

El algoritmo del Z-buffer es del tipo espacio-imagen. Cada vez que se va a renderizar un pixel, comprueba que no se haya dibujado antes en esa posición un pixel que esté más cerca respecto a la cámara. Este algoritmo funciona bien para cualquier tipo de objetos: cóncavos, convexos, abiertos y cerrados. Para activarlo, hay que hacer una llamada a:

glEnable(GL_DEPTH_TEST)


Esta llamada le dice a OpenGL que active el test de profundidad. Además, cada vez que se redibuje la escena, a parte de borrar el buffer de color, hay que borrar el buffer de profundidad. Esto se hace con la llamada:

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) .

Por último, pero no menos importante, al inicializar OpenGL se le tiene

que decir que cree el buffer de profundidad. Esto se hace al definir el modo de visualización (ver capítulo GLUT).

Figura 33 - Sin Z-Buffer Figura 34 - Con Z-Buffer

7.8.5.3. Combinando ambos algoritmos

El algoritmo de la eliminación de las caras de detrás es suficiente para renderizar para objetos convexos y cerrados, como este octahedro, pero para objetos cóncavos y cerrados no basta. Por ejemplo, un objeto con una cara parcialmente oculta, como el de la figura, no tiene porqué renderizarse bien:

Figura 35 - Sin ocultaciones Figura 36 - Eliminando caras de detrás Ahora bien, si sabemos que todos nuestros objetos están cerrados , es

decir, no se ve el interior, podemos combinarlo con el Z-buffer, ya que descartaremos ya para empezar las caras que no vamos a ver, ganando así en velocidad de renderización.


Figura 37 - Z-Buffer Figura 38 - Caras de detrás + Z-Buffer

Ahora bien, la combinación de estos dos algoritmos no siempre es

adecuada. En el caso de la tetera, por ejemplo, puesto que la tapa no está perfectamente ajustada a la tetera, y por tanto, queda un hueco (es decir, se ve el interior) ¡Si utilizamos el algoritmo de las caras de detrás veremos a través! Por tanto, en este caso lo mejor es utilizar sólo el algoritmo del Z-buffer.

Figura 39 - Caras de detrás + Z-Buffer Figura 40 - Sólo Z-Buffer

7.8.6. El color de los materiales La forma en que la luz incide sobre las superficies de los objetos

depende de las propiedades del material de los mismos. En OpenGL la forma de definir estas propiedades es la función glMaterial cuya sintaxis es void glMaterial{if}[v](GLenum face, GLenum pname, TYPEpa ram);

El primer argumento determina la cara del objeto donde se aplica el material, puede tomar los valores GL_FRONT, GL_BACK , o GL_FRONT_AND_BACK .

El siguiente argumento indica la propiedad del material que va a fijarse (sus posibles valores se muestran en la tabla). Finalmente, el argumento param permite asignar los valores a la propiedad pname .


Nombre del parámetro Valor por

defecto

Significado

GL_AMBIENT (0.2, 0.2, 0.2,

1.0)

ambient color of material

GL_DIFFUSE (0.8, 0.8, 0.8,

1.0)

diffuse color of material

GL_AMBIENT_AND_DIFFUSE ambient and diffuse color of

material

GL_SPECULAR (0.0, 0.0, 0.0,

1.0)

specular color of material

GL_SHININESS 0.0 specular exponent

GL_EMISSION (0.0, 0.0, 0.0,

1.0)

emissive color of material

GL_COLOR_INDEXES (0,1,1) ambient, diffuse, and specular

color indices

Reflexión ambiente y difusa

La reflexión difusa determina el color de un objeto y la reflexión ambiente la forma en que el objeto redistribuye la luz ambiente que recibe. Los objetos del mundo real suelen tener el mismo color de reflexión ambiente y difusa.

Reflexión especular

La componente especular define el color de los brillos del objeto cuya forma se controla con el parámetro GL_SHININESS de modo que cuando mayor sea este parámetro el brillo aparecerá más concentrado.

Emisión

OpenGL permite asignar a los objetos un color de emisión para que parezca que dichos objetos emiten luz de un color, lo que permite simular lámparas y objetos luminosos. Se pueden conseguir mejores efectos simulando fuentes de luz en la misma posición que los objetos para los que se define un color de emisión.

Cambio de las propiedades del material

Para minimizar el coste asociado a la realización de cambios en las propiedades del material se usa la función glColorMaterial cuya sintaxis es la siguiente:


Cara podrá tomar los valores GL_FRONT_AND_BACK , GL_FRONT o GL_BACK y modo GL_AMBIENT_AND_DIFFUSE , GL_DIFFUSE, GL_SPECULAR o GL_EMISIÓN.

Una vez que se realiza la llamada a la función, se puede cambiar el color de la propiedad que indica el parámetro modo para la cara definida en cara usando glColor .

Después de llamar a la función glColorMaterial es necesario realizar una llamada a glEnable con el argumento GL_COLOR_MATERIAL .

glColorMaterial(GL_FRONT, GL_DIFFUSE);

glEnable(GL_COLOR_MATERIAL);

glColor3f(0.2, 0.5, 0.8);

......../* dibujamos algo aquí */

glColor3f(0.9, 0.0, 0.2);

......... /*y otros */

glDisable(GL_COLOR_MATERIAL);

Listado 5 - Definiciones para materiales

Veamos un ejemplo de todo esto:

#include <windows.h>

Propósito: Permite que los colores del material sigan el color definido

por glColor.

• Fichero de inclusión: <gl.h>

• Sintaxis: void glColorMaterial(GLenum cara, GLenum modo);

• Descripción: Esta función permite seleccionar las propiedades de un

material sin tener que llamar directamente a glMaterial. Usando esta

función, podemos definir ciertas propiedades del material siguiendo

el color especificado actualmente por glColor. Para habilitar el

seguimiento, llamaremos a glEnable(GL_COLOR_MATERIAL).

• Parámetros:

func

• Retornos: Ninguno.


#include <GL/gl.h>

#include <GL/glut.h>

GLfloat mat_diffuse [] = {0.5, 0.5,

0.5, 1.0};

GLfloat mat_specular [] = {0.5, 0.5,

0.5, 1.0};

GLfloat mat_shininess [] = {50};

void init (void)

{

GLfloat light_position[] = {1.0, 1.0,

1.0, 0.0};

glLightfv(GL_LIGHT0, GL_POSITION,

light_position);

glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);

glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);

glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess) ;

glEnable (GL_LIGHTING);

glEnable (GL_LIGHT0);

glDepthFunc(GL_LEQUAL);

glEnable (GL_DEPTH_TEST);

}

void display (void)

{

int i,j;

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BI T);

for (i=-1; i<=1; i++)

{

for (j=-1; j<=1; j++)

{

glPushMatrix();

Figura 41 - Color de materiales


glTranslatef((float)i*3.0,(float)j*3.0,0.0);

glutSolidSphere(1.0,16,16);

glPopMatrix();

}

}

glutSwapBuffers();

}

void reshape(int w, int h)

{

glViewport ( 0, 0, w, h );

glMatrixMode ( GL_PROJECTION );

glLoadIdentity ( );

if ( h==0 )

gluPerspective ( 60, ( float ) w, 1.0, 20 .0 );

else

gluPerspective ( 60, ( float ) w / ( float ) h,

1.0, 20.0 );

glMatrixMode ( GL_MODELVIEW );

glLoadIdentity ( );

gluLookAt(0.0,0.0,10.0,0.0,0.0,0.0,0.0,1.0,0.0);

}

/* Ciclo principal

* Abre una ventana con tamaño inicial definido, b arra de

titulo,

* modo RGB, y control de eventos */

int main (int argc, char** argv)

{

glutInit (&argc, argv);


glutInitDisplayMode (GLUT_RGB | GLUT_DOUBLE |

GLUT_DEPTH);

glutInitWindowSize (250,250);

glutInitWindowPosition (100,100);

glutCreateWindow ("Ejemplo de luz");

init ();

/* llamada a inicializacion*/

glutReshapeFunc (reshape); /* llamada

para eventos de reshape de ventana*/

glutDisplayFunc (display); /* llamada

para dibujar...*/

glutMainLoop (); /* Crea la

ventana y dibuja...*/

}

Listado 6 - Ejemplo uso de propiedades de materiales

Colores y sombras

58

7.9. Sombras

Una sombra es una región de oscuridad donde la luz es obstaculizada. Una sombra ocupa todo el espacio de detrás de un objeto opaco con una fuente de luz frente a él. La sección eficaz de una sombra es una silueta bidimensional o una proyección invertida del objeto que bloquea la luz.

Cuanto menor es el ángulo entre la dirección de la luz y un objeto alargado que la obstaculice, más corta será su sombra. Por otro lado, cuanto menor sea el ángulo entre la dirección de la luz y la superficie en la que aparece la sombra, más larga será ésta. Si el objeto está cerca de la fuente luminosa, la sombra será mayor que si el objeto se encuentra lejos. Si la superficie está curvada, habrá más distorsiones.

Cuando la fuente de luz no es puntual, la sombra se divide en umbra y

penumbra. Cuanto más ancha es la fuente de luz, más difuminada o borrosa será la sombra.

Si hay múltiples fuentes luminosas, habrá múltiples sombras, con las

partes solapadas más oscuras, o con una combinación de colores. Cuando una persona o un objeto está en contacto con la superficie, como una persona sentada en el suelo o un poste clavado, las sombras convergen al punto de contacto.

Si sólo existe una fuente de luz, las sombras arrojadas por aquella serán

siempre grises, sea cual sea el color de la fuente. En cambio, si existen dos fuentes de luz de distintos colores, supongamos rojo y azul, las sombras proyectadas por cada una de ellas serán del color de la otra fuente de luz, y sólo la intersección de ambas sombras será gris. Es decir, la sombra de la luz roja será azul, pues está iluminada por la fuente azul, y viceversa. En el caso de que existan más fuentes de luz, cada sombra será del color resultante de la adición de las fuentes que aún iluminan esa zona, permaneciendo en gris las zonas donde intersecten las sombras de todas las fuentes luminosas.

El proceso de sombreado o shading (en el contexto de los gráficos

realizada por ordenador) implica la simulación de computadora (o más exactamente; el cálculo) como las caras de un polígono se comportarán cuando es iluminado por una fuente de la luz virtual. El cálculo exacto varía según no sólo que datos están disponibles sobre la cara sombreada, sino también la técnica de sombreado.

Generalmente este afecta propiedades de la especularidad y valores de

intensidad, reflexión y transparencia. Este proceso se realiza durante el renderizado. El sombreado altera el color de las caras de un modelo 3D basándose

en el ángulo de la superficie con la fuente de luz. Las siguientes imágenes muestran las diferencias:

Colores y sombras

59

Figura 42 Imagen renderizada de una caja.

Esta imagen no tiene sombreado de las caras, pero usa líneas en los

bordes para separar las caras.

Figura 43 Imagen sin líneas en los bordes

Aquí se observa como el sombreado altera el color de las 3 caras basándose en el ángulo de las fuentes de luz.

Figura 44 Imagen son sombreado en las caras

Colores y sombras

60

7.9.1 Efecto falloff (Distance falloff)

Teóricamente, dos superficies que son paralelas son iluminadas con la misma intensidad por una fuente de luz distante, como por ejemplo el sol. Incluso si una superficie está más distante, el ojo ve más en el mismo espacio, por eso la iluminación parece la misma.

Nótese que en la primera imagen el color de las caras frontales de las dos cajas son exactamente iguales. Parece que hay una pequeña diferencia en el punto de encuentro de las caras, pero esto es una ilusión óptica causada por el borde vertical debajo de donde se encuentran las caras.

En la segunda imagen se puede observar que las superficies de las

caras son brillantes en la caja delantera y más oscuras en la situada en la parte de atrás. También la superficie sobre la que están pasa de claro a oscuro según se aleja.

Este efecto falloff produce imágenes que parezcan más realistas.

Figura 45 Cajas renderizadas con OpenGL

Figura 46 Cajas renderizadas con ARRIS CAD, efecto falloff

Un modelo de intensidad puede aplicarse al sombreado de superficies de

varias formas dependiendo del tipo de superficie y de los requisitos de la aplicación. Los objetos con varias superficies suelen sombrearse de forma realista con una sola intensidad por cada superficie. Para una superficie curva

Colores y sombras

61

podríamos aplicar el modelo de intensidad a cada punto de la superficie; aunque esto produce un efecto muy realista es un proceso muy lento.

Para acelerar el proceso se podría representar una superficie curva

como un conjunto de polígonos y aplicar el modelo de sombreado a cada plano. Cada una de estas superficies poligonales podría sombrarse después con intensidad constante o bien podríamos variar el sombrado con valores de intensidad interpolados.

Los algoritmos de superficies visibles determinan qué superficies ve el

ojo dependiendo de su posición. Los algoritmos de sombras determinan que objetos se ven desde la fuente de luz. Por tanto, estos dos tipos de algoritmos son esencialmente iguales. Las superficies visibles desde la fuente de luz están iluminadas, las no visibles están en sombra.

Cuando hay múltiples fuentes de luz una superficie debe clasificarse

respecto a cada fuente de luz. Consideraremos en este tema algoritmos de sombra para fuentes de luz puntuales. La visibilidad a partir de una fuente puntual de luz es como la visibilidad en el ojo: “todo o nada”.

Cuando un punto en la superficie no puede verse desde una fuente

puntual de luz, el cálculo de iluminación debe ajustarse para tenerlo en cuenta. Las áreas en la sombra de todas las fuentes puntuales de luz todavía

están iluminadas por la luz ambiente. Aunque la utilización de sombras requiere el cálculo de la visibilidad de la

fuente de luz, pueden generarse sombras falsas sin hacer pruebas de visibilidad.

7.9.2 Sombreado

La intensidad de luz que se observa en cada superficie de un objeto

depende del tipo de fuentes de luz que la ilumine y de las características de la superficie del objeto. Algunos objetos tienen superficies brillantes y otros opacas o mate. Además, algunos objetos se construyen con materiales opacos, mientras que otros son mas o menos trasparentes. Un modelo de sombreado para producir intensidades realistas sobre las superficies de un objeto debe considerar estas propiedades.

Los patrones de sombra generados por un método de superficie oculta son validos en cualquier posición de visión seleccionada siempre que las posiciones de la fuente de luz no se alteren. Las superficies que son visibles desde la posición de visión se sombrean según el modelo de intensidad, con patrones de superficie y sombras anexados. Las superficies visibles que no son iluminadas por una fuente de punto se les aplica únicamente intensidad de luz ambiental. Las superficies visibles que son iluminadas por una fuente de puntos

Colores y sombras

62

se sombrean combinando el modelo de intensidad y la lista de patrones. Las áreas de sombra proyectada se sombrean únicamente con la intensidad de la luz ambiental.

Asumiendo que se puede computar vectores normales, dado un conjunto de fuentes de luz y un observador, los modelos de luz e iluminación desarrollados pueden aplicarse a cada punto de una superficie. Lamentablemente, aunque se tenga ecuaciones sencillas para determinarlos vectores normales, la cantidad de computaciones requeridas puede ser muy grande. Se han visto muchas de las ventajas de usar modelos poligonales para los objetos. Una ventaja adicional, para polígonos planos, es que se puede reducir bastante el trabajo requerido para el sombreado. La mayoría de los sistemas gráficos, incluyendo OpenGL, explota las posibles eficiencias para polígonos planos, descomponiendo superficies curvas en muchos polígonos planos pequeños, cada uno teniendo un vector normal bien definido.

7.9.3 Tipos de sombreado

7.9.3.1 Sombreado plano (Flat Shading)

Es una técnica usada en gráficos 3D en la que se sombrea cada polígono de un objeto basándose en el ángulo que existe entre la superficie normal del polígono y la dirección de la fuente de luz, sus respectivos colores y la intensidad de la luz. Es el tipo de sombreado utilizado para el renderizado de alta velocidad donde técnicas de sombreado más avanzadas tienen un coste computacional excesivo.

La desventaja del sombreado de intensidad constante es que da a los

modelos con un número bajo de polígonos un aspecto poco natural, formado por múltiples caras. A veces esta apariencia puede ser ventajosa, como al modelar objetos poligonales. Los diseñadores a veces usan esta técnica para observar las diferentes caras del objeto que están creando.

Bajo ciertas restricciones se puede obtener un sombreado realista en un

objeto con superficies planas utilizando intensidades con superficies constantes. Si el objeto está únicamente expuesto a luz ambiental y no se aplican texturas, sombras de superficie, etc., el sombreado de intensidad constante genera representaciones exactas de la superficie del objeto. Para objetos cuya superficie se ilumina con un foco de luz puntual el modelo produce una superficie de intensidad constante siempre que el punto de referencia visual y el foco estén suficientemente alejados de la superficie del objeto. Si por el contrario el foco está alejado de la superficie no hay variación en la dirección hacia la fuente. La dirección hacia un punto de visión distinto no cambiara sobre una superficie, por lo tanto V.R = cte.

Si se representa mediante un conjunto de superficies planas una

superficie curva y los planos que subdividen esta superficie se hacen lo suficientemente pequeños. Se pueden sombrear con intensidades de superficie constante.

Colores y sombras

63

Cuando la orientación entre planos adyacentes cambia en forma

abrupta, la diferencia en intensidades de superficie puede producir un efecto áspero e irreal. Se pueden aliar las discontinuidades de intensidad en estos casos variando la intensidad sobre cada superficie de acuerdo con algún esquema de interpolación.

Existen otro tipo de técnicas de sombreado más avanzadas como el

sombreado de Gouraud y el sombreado de Phong.

Figura 47 Comparación de las técnicas de sombreado

7.9.3.2 Sombreado de Gouraud

Creada en 1971 y llamada así en honor a Henri Gouraud, este método es usado para simular el efecto de difusión de de la luz y los colores a través de la superficie del objeto, esta técnica consigue alcanzar el sombreado de superficies con pocos polígonos sin el alto coste computacional de calcular la iluminación de cada píxel.

El sombreado de Gouraud aplica el patrón de iluminación a cada vértice del polígono y entonces promedia los valores de color en toda la superficie del objeto para así alcanzar un efecto de sombreado suave que parece más realista sobre superficies curvas.

Este método de sombreado se emplea para disimular los polígonos cuando éstos se emplean para aproximar una superficie curva, como una esfera o un toroide, por ejemplo.

El método es el siguiente: primero calculamos las normales a la superficie en los vértices de los polígonos. Esta normal en cada punto podemos calcularla de dos maneras: 1ª-basándonos las características de la superficie que vamos a aproximar, por ejemplo si se trata de una esfera, sabemos que la normal va a ir en dirección opuesta al centro de la esfera. 2ª- Si no conocemos la superficie que estamos aproximando, podemos sumar todas las normales de los polígonos de los que forme parte ese vértice y normalizar el resultado.

Colores y sombras

64

Una vez hecho esto, calculamos por los procedimientos de iluminación vistos anteriormente el color que correspondería a cada vértice. Después, cuando vamos a dibujar el polígono, vamos interpolando linealmente a través de cada arista entre los dos colores de los extremos de dicha arista, y por último al ir trazando las líneas horizontales (o scanlines) que forman el polígono, interpolamos de nuevo linealmente entre los dos valores que correspondan a los puntos de las dos aristas entre las que estemos trazando la línea horizontal. El resultado final de todo esto es un polígono con un suave gradiente de intensidades sobre su superficie.

Se puede ver gráficamente esto con el ejemplo de la figura 48, en la que conocemos los valores de la intensidad en los puntos 1 2 y 3. Al ir dibujando el triángulo, calculamos los valores del primer y el ultimo píxel del triangulo en cada línea interpolando, a lo largo de las aristas, los valores de los vértices. Esto nos da el valor inicial y el final de cada línea horizontal, y para rellenarla solo tenemos que interpolar linealmente de nuevo los estos valores a lo largo de la línea.

Un vector normal a una superficie es un vector que apunta en una dirección perpendicular a dicha superficie. Si partimos de un triángulo, con tres vértices P1, P2 y P3, el procedimiento para calcular la normal es muy sencillo; se escoge un punto como origen, digamos P2, y se calculan los vectores v1=P1-P2, y v2=P3-P2; calculamos el producto vectorial entre V1 y V2, y nos sale el vector normal.

Además, puesto que el vector normal prácticamente solo se va a usar para calcular su ángulo con otros vectores, es muy útil hacer que su módulo sea uno, dividiendo cada una de las componentes (x,y,z) entre el módulo del vector.

En la figura se ve un triángulo con su vector normal. Una cosa que hay que tener en cuenta al calcular un vector normal a un triangulo, es que el producto vectorial no cumple la propiedad conmutativa, o sea que hay que tener cuidado porque según en que orden se multipliquen v1 y v2 el vector normal puede apuntar en una dirección o en la opuesta.

La aplicación de las normales a la hora de acelerar el dibujado de polígonos es la siguiente: como normalmente los triángulos se usan para representar aproximaciones a superficies, como por ejemplo esferas, se puede considerar que tales

Figura 48 - Scanlines

Figura 49 - Normal

Figura 50 - Normales

Colores y sombras

65

superficies tienen una cara interior que no se ve (el interior de la esfera, p ej) y una exterior que si se ve. Entonces, podemos calcular las normales a los triángulos asegurándonos de que apunten al exterior de la superficie, y después eliminar los polígonos cuya normal no apunte en dirección a la pantalla, porque se entiende que estamos viendo su parte trasera y por tanto no se dibuja. En la figura vemos un ejemplo en 2D de este método. En este caso, hay una serie de segmentos que aproximan una circunferencia. Descartamos por medio de las normales las caras 4, 5, 6 y 7 y dibujamos las caras 1 2 y 3. A estas tres caras que vamos a dibujar hay que aplicarles otro algoritmo para verificar superficies ocultas, como el del pintor o el buffer z, ya que el método de las normales no garantiza que las caras que apuntan hacia la cámara no vayan a estar parcial o totalmente tapadas por otro objeto.

Algunas veces los objetos sombreados con Gouraud muestran las zonas de unión de polígonos conocido como el efecto de la banda de Mach. Este fenómeno es una consecuencia de como se conectan los conos al nervio óptico en el ojo, y no hay nada que se pueda hacer al respecto, fuera de buscar técnicas de sombreado mas suaves que no produzcan grandes diferencias en sombreado en los bordes de los polígonos.

Figura 51 Sombreado Gouraud banda de Mach

7.9.3.3 Sombreado de Phong

Es el método usado en los gráficos 3D para la interpolación de superficies en el pasterizado de polígonos, para obtener mejor resolución especular que en las generadas en el modelo de reflexión de Pong.

Este método fue desarrollado por Bui Tuong Phong en 1973 en la

universidad de Utah. El modelo de reflexión de Phong es un modelo de iluminación local que puede producir un cierto grado de realismo en los objetos 3D mediante la combionación de e elementos: difusión, reflexión especular y luz ambiente para cada punto de la superficie considerada.

Colores y sombras

66

La interpolación de Phong , como método de renderizado, se peude considerar como una mejora del sombreado de Gouraud que proporciona una mejor aproximación a la aplicación punto-por-punto de un modelo de reflexión superficial, asumiendo una suavidad variante de la superficie como vector normal.

Para ello se determina el vector normal promedio en cada vértice del

polígono. Se interpola linealmente los vértices normales sobre la superficie del polígono. Se aplica un modelo de iluminación sobre los puntos de la superficie utilizando las normales interpoladas.

Phong propuso que, en lugar de interpolar intensidades de los vértices,

según se hace en el sombreado Gouraud, se interpole normales a lo largo del polígono. Para un polígono que comparte lados y vértices con otros polígonos,

Figura 52 - Esquema

se pueden computar normales en los vértices interpolando sobre las normales de los polígonos que comparten el vértice. Luego, se puede usar interpolación bilineal, para interpolar las normales sobre el polígono

Figura 53 - Esquema

Se puede usar las normales interpoladas en los vértices A y B para

interpolar a lo largo de lado entre ellas: n(�) = (1-�)nA + �nB

Se puede hacer una interpolación similar en todos los lados. LA normal en cualquier punto interior se puede obtener de los puntos en los lados mediante

n(�,�) = (1-�)nC + �nD

Colores y sombras

67

Una vez obtenidas las normales en cada punto, se puede hacer cálculos de sombreado independientes. Normalmente, este proceso se combinará con la rasterización del polígono, para que la línea entre C y D proyecte a una línea de rastreo en el frame buffer. 7.9.3.4 Sombreado Blinn–Phong

Es una variante del modelo de reflexión de Phong que intercambia la precisión visual por eficiencia computacional.

En sombrado de Phong solo se recalcula el ángulo R*V entre el

observador (V) y el rayo de luz de la fuente (L) reflejado (R) en una superficie. Si en vez de eso se calcula el vector intermedio entre el observador y los vectores de las fuentes de luz:

Podemos reemplazar R*V con N*H, este producto de puntos representa el coseno de un ángulo que es la mitad del ángulo representado por el producto de puntos de Phong si V,L y R se encuentran en el mismo plano. Esto produce modelos empíricos más certeros para determinar la distribución de las funciones de reflexión bidireccional que el modelo de Phong. Blinn-Phong es el modelo de sombreado por defecto que utiliza OpenGL y se lleva a todos los vértices según pasan por la tubería de gráficos, mientras que los valores de los pixeles entre los vértices son interpolados por el sombreado de Gouraud (menos costoso).

Figura 54 Sombreado de Phong y Blinn-Phong

Colores y sombras

68

7.9.4 Sombreado en OpenGL

Se especifica la técnica de sombreado deseada con la función

glShadeModel. Void glShadeModel(Glenum mode); El parámetro mod puede tener 2 valores GL_SMOOTH (por defecto) o

GL_FLAT. 7.9.4.1 Sombreado Plano (Flat)

Los tres vectores, l, n y v, pueden variar según se va entre puntos sobre una superficie.

* Para un polígono plano, n es constante. * Si se asume un observador distante (la bandera

GL_DISTANT_VIEWER en OpenGL), v es constante sobre el polígono. *Si la fuente de luz es distante, l es constante. Distante se puede interpretar como una fuente o un observador en el

infinito; en particular, si los polígonos son pequeños, las distancias relativas para el infinito no tienen que ser muy grandes. Los ajustes necesarios, como cambiar la ubicación de la fuente u observador a la dirección de la fuente u observador, de forma correspondiente, puede hacerse a las ecuaciones de sombreado y a su implementación.

Si los tres vectores son constantes, entonces el cálculo de sombreado

se lleva a cabo una sola vez para cada polígono, y se asignará la misma sombra a cada punto en el polígono. Esta técnica se conoce como sombreado plano o constante . En OpenGL, se especifica sombreado plano mediante

glShadeModel(GL_FLAT); Si se usa sombreado plano, OpenGL usará las normales asociadas con

el primer vértice de un polígono Sencillo para el cálculo de sombreado. Para primitivas como un strip de

triángulo, OpenGL usa la normal del tercer vértice para el primer triángulo, la normal del cuarto vértice para el segundo, etc. Reglas similares se aplican para otras primitivas, como strips cuadriláteros.

Sombreado plano mostrará diferencias de sombreado entre los

polígonos. Si las fuentes de luz y el observador están cerca del polígono, los vectores v y l serán diferentes para cada polígono. Sin embargo, si los polígonos se diseñaron para modelar una superficie suave, sombreado plano no será el mas apropiado, ya que se verán aunque sea diferencias de sombreado pequeñas entre polígonos adyacentes.

Colores y sombras

69

Figura 55 Variación se sombreado

El sistema visual humano tiene una sensibilidad remarcada para

pequeñas diferencias de intensidad de color, causada por la propiedad de inhibición lateral . Si se ve una secuencia incremental de intensidades, se percibe los incrementos de brillantez reforzados en un lado del intervalo de intensidad y decremento de brillantez reforzado del otro lado

Figura 56 Percepción de intensidad

Ejemplo de código en Open GL

Figura 57 Sombreado G_FLAT

glShadeModel(GL_FLAT); glBegin(GL_TRIANGLES); glColor3f(1.0f, 0.0f, 0.0f); // activamos el color rojo glVertex3f(-1.0f, 0.0f, 0.0f); glColor3f(0.0f, 1.0f, 0.0f); // activamos el color verde glVertex3f(1.0f, 0.0f, 0.0f); glColor3f(1.0f, 0.0f, 0.0f); // activamos el color azul glVertex3f(0.0f, 1.0f, 0.0f); glEnd();

Colores y sombras

70

El triángulo se rellena con el color azul, puesto que el modelo de sombreado es GL_FLAT y el color activo en la definición del último vértice es el azul.

7.9.4.2 Sombreado Interpolativo y Gouraud

Si se asigna el modelo de sombreado para que sea suave, mediante glShadeModel(GL_SMOOTH); OpenGL interpolará colores para las primitivas, como las líneas. Si se permite sombreado y luz suaves, y se asigna a cada vértice la normal del polígono siendo sombreado, se calcularía la luz en cada vértice, determinando el color del vértice, usando las propiedades materiales y los vectores v y l se computan para cada vértice. Si la fuente de luz es distante, y el observador es distante o no hay reflexiones especulares, entonces el sombreado interpolativo sombreara un polígono con un color constante.

Desde la perspectiva de OpenGL, el sombreado Gouraud es deceptivamente sencillo. Se necesita solamente asignar correctamente las normales de vértices. La literatura a menudo no distingue entre el sombreado interpolativo y el Gouraud. Sin embargo, existe un problema, encontrar las normales para promediar. Si el programa es lineal, especificar una lista de vértices (y otras propiedades), no se tiene la información necesaria de cuales polígonos comparten un vértice. Lo que se requiere es una estructura de datos para representar un "mesh". Atravesar esta estructura de datos puede generar los vértices con las normales promediadas. Tal estructura de datos debe contener, de manera mínima, polígonos, vértices, normales, y propiedades de los materiales. Una posible estructura se muestra en al siguiente figura, teniendo como elemento clave los polígonos que se juntan en cada vértice

Figura 58 Estructura de datos para facilitar sombreado

Colores y sombras

71

Ejemplo de código OpenGL

Figura 59 Sombreado GL_SMOOTH

7.9.4.3 Stencil Buffer

Sirve para mejorar la calidad de las sombras y los reflejos. Es un test extra por píxel y un conjunto de operaciones muy parecidas al

Z-Buffer.

Añade planos de bits adicionales para cada píxel además de los bits de color y profundidad.

Es una manera de marcar píxeles en una renderización para controlar su actualización en renderizaciones siguientes.

El valor stencil de un píxel es un entero sin signo (unsigned int). Para activar y desactivar el test de stencil se utilizará la función

glEnable(GL_STENCIL_TEST) y glDisable(GL_STENCIL_TEST) . Para borrar el stencil buffer se usará la función glClearStencil cuya

sintaxis es la siguiente:

glShadeModel(GL_SMOOTH); glBegin(GL_TRIANGLES); glColor3f(1.0f, 0.0f, 0.0f); // activam os el color rojo glVertex3f(-1.0f, 0.0f, 0.0f); glColor3f(0.0f, 1.0f, 0.0f); // verde glVertex3f(1.0f, 0.0f, 0.0f); glColor3f(1.0f, 0.0f, 0.0f); // azul glVertex3f(0.0f, 0.0f, 1.0f); glEnd();

Colores y sombras

72

• Propósito: Especifica un valor de estarcido para el buffer de estarcido.

• Fichero de inclusión: <GL/gl.h>

• Sintaxis: void glClearStencil(GLint valor);

• Descripción: Esta función selecciona el valor de color que usaremos

para borrar el buffer de estarcido con

glClear(GL_STENCIL_BUFFER_BIT).

• Parámetros:

valor

GLint: el valor de limpieza del buffer de estarcido.


El stencil test compara el valor del píxel del stencil buffer con un valor de

referencia. Permite las comparaciones: never, always, less than, less than or equal, greater than, greater than or equal, equal, not equal.

Es más potente que el buffer de profundidad. Antes de comparar realiza

una operación AND tanto del valor de referencia como del valor del buffer, con un valor que sirve como máscara.

GlStencilFunc(GL_EQUAL, 0x1,0xff). El primer parámetro será la función de comparación, el segundo el valor

de referencia y el tercero la máscara. Si el píxel no pasa el test de profundidad es rechazado, en cambio, si lo

pasa, se reemplaza el valor del Z-Buffer. El stencil test es más complicado: - No pasa el stencil test - Pasa stencil test y no el test de profundidad - Pasa stencil test y test de profundidad Para cada caso tenemos 6 operaciones distintas: GL_KEEP,

GL_REPLACE, GL_INVERT, GL_INCREMENT, GL_DECREMENT, GL_ZERO. Antes de escribir se aplica un máscara: GlStencilOp(GL_KEEP //Stencil fail GL_DECR //Pasa el stencil y falla la profundidad GL_INCR //Pasa el stencil y pasa la profundidad) GlStencilMask(0xff);

Colores y sombras

73

State Description

Initial Value State Update Command

State Query Token

Stencilling enable

GL_FALSE glEnable glDisable

GL_STENCIL_TEST

Stencil function

GL_ALWAYS glStencilFunc GL_STENCIL_FUNC

Stencil compare mask

All 1’s glStencilFunc GL_STENCIL_VALUE_MASK

Stencil reference value

0 glStencilFunc GL_STENCIL_REF

Stencil fail operation

GL_KEEP glStencilOp GL_STENCIL_FAIL

Stencil depth fail operation

GL_KEEP glStencilOp GL_STENCIL_PASS_DEPTH_PASS

Stencil depth pass operation

GL_KEEP glStencilOp GL_STENCIL_PASS_DEPTH_PASS

Stencil write mask

All 1’s glStencilMask GL_STENCIL_WRITEMASK

Stencil buffer clear value

0 glClearStencil GL_STENCIL_CLEAR_VALUE

Tiene una serie de limitaciones:

- El objeto reflejado sale por fuera de la superficie reflectante - Desde detrás del espejo se ve el objeto reflejado. - No permite reflejos infinitos. Está limitado a n reflejos.

A continuación se muestra el algoritmo para el empleo del stencil para simular sombras:

1.- Cargar la matriz de modelización.

GlMatrixMode(GL_MODELVIEW);

GlLoadIdentity();

GlLookAt(eye[0], eye[1], eye[2], center[0], center[1], center[2], up[0], up[1], up[2]);

2.- Dada la luz y la ecuación del plano donde se proyecta, asumiendo que el objeto esta entre la luz y el plano, habilitar la luz y renderizar el objeto y el plano

Glfloat lightPosition[4]={LX,LY,LZ,1.0);

Glfloat groundPlaneEquation[4]={A,B,C,D};

Colores y sombras

74

GlLightfv{GL_LIGHT0, GL_POSITION,lightPosition);

GlEnable(GL_LIGHT0);

GlEnable(GL_LIGHTING);

DibujarObjeto();

DibujarPlano();

3.- Meter en la pila la matriz de modelización

glPushMatrix();

4.- Construir la matriz de proyección, multiplicar la matriz de modelización por la matriz de proyección de la sombra.

Glfloat Matriz[4][4];

ShadowMatrix(&matriz[0][0], LightPosition, groundPlaneEquation);

glHultMatrix(&Matriz[0][0]);

5.- Asignar un valor distinto de 0 al stencil buffer

glEnable(GL_STENCIL_BUFFER);

glStencilFunc(GL_ALWAYS, valor, ~0);

glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

DibujarPlanoASombrear();

GlDisable(GL_STENCIL_TEST);

6.- Deshabilitar la iluminación

glDisable(GL_LIGHTING);

glEnable(GL_BLEND);

glBlendFunc(GL_DST_COLOR,GL_ZERO);

glColor3f(0.5,0.5,0.5);

glDisable(GL_DEPTH_TEST);

Solo debemos actualizar los pixeles marcados con valor

GlEnable(GL_STENCIL_TEST);

GlStencilFunc(GL_EQUAL, valor, ~0);

GlStencilOp(GL_KEEP, GL_KEEP,GL_ZERO);

DibujarObjeto();

7.- Restaurar los valores

Colores y sombras

75

glDisable(GL_BLEND);

glDisable(GL_STENCIL_TEST);

glEnable(GL_DEPTH_TEST);

glPopMatrix();

7.9.4.4 Buffer de Profundidad o Z buffer

Este buffer se utiliza para el manejo de las coordenadas de profundidad de la imagen 3D. Esta es una solución al problema de visibilidad, para detectar que objetos de una imagen renderizada son visibles y cuales no. Cuando un objeto es renderizado por una tarjeta gráfica 3D, la profundidad de cada píxel es almacenada en un buffer (z-buffer). Este está normalmente formado por un array bidimensional con un elemento para cada píxel de la pantalla. Si otro objeto de la escena tiene q renderizarse en el mismo píxel, la tarjeta gráfica compara las dos profundidades y elige la que está más cercana al observador. Entonces la profundidad elegida es almacenada en el z-buffer, reemplazando a la anterior. Al final este buffer permite a la tarjeta gráfica reproducir fielmente la percepción de profundidad, un objeto cercano tapa a los de más lejos. La granularidad del z-buffer tiene una gran influencia en la calidad de la imagen: un buffer de 16 bits puede finalizar en conflicto cuando dos objetos están muy cercanos. Uno de 24 o 32 se comporta mucho mejor y uno de 8 casi nunca se usa porque tiene muy poca precisión.

Figura 60 Buffer de profundidad

Colores y sombras

76

7.9.5. Volúmenes de sombras

Para construir un volumen de sombras básicamente se proyecta un rayo de luz a través de cada vértice en la proyección de la sombra del objeto hacia algún punto (normalmente el infinito). El conjunto de estas proyecciones generan un volumen que engloba todos los puntos que pudieran posiblemente verse ensombrecidos por un objeto. Cualquier objeto dentro de este volumen debería ser ensombrecido. El volumen es presentado de tal modo que causa píxeles ensombrecidos tener valores estarcidos. que difieren de aquellos píxeles no sombreados.

Para un modelo poligonal, el volumen esta formado normalmente por la

clasificación de cada cara en el modelo ya sea encarándose hacia la fuente de luz o en su contra. El conjunto de todos los bordes que conectan la cara “hacia” con la cara “contra” forman la silueta con respecto a la fuente de luz. Los bordes que forman la silueta son excluidos de la luz para construir las caras del volumen de sombra. Este volumen debe extenderse sobre el rango total de la escena visible; a veces las dimensiones del volumen de sombra se extienden hasta el infinito. Para formar un volumen cerrado, el frente y la trasera de esta extrusión deben ser cubiertas. Estas cubiertas se llaman “caps”. Dependiendo del método usado para el volumen de sombra, el frente puede cubrir al objeto mismo y la parte trasera puede ser omitida.

Los pasos para formar un volumen de sombras son:

• Encontrar todos los bordes de siluetas. • Extender todos los bordes en dirección al foco de luz • Añadir la capa frontal y trasera a cada superficie para formar un

volumen cerrado.

Figura 61 Volumen de sombras

Colores y sombras

77

Determinar y visualizar el volumen ensombrecido es la parte más compleja de la técnica. Aunque se esté utilizando un método muy simple para la creación de volúmenes de sombras de geometría simple en este trabajo no sería eficiente para el caso de miles de polígonos. También puede ocurrir que el método cause algunos lugares donde los bordes de las sombras de los volúmenes se encuentren. ( Debido a que hay un único volumen sombreado para cada polígono). Esto puede solucionarse visualizando un único volumen que rodee el modelo entero en lugar de presentar los distintos volúmenes de cada polígono separados.

Efectos a tener en cuenta son:

• Umbría y penumbra para producir una transición gradual • La forma, tamaño y distancia de las fuentes de luz • La iluminación global

Figura 62 Efecto de la fuente en la sombra

Figura 63 Volumen sombras en un triángulo

Existen 3 técnicas que usan el stencil buffer para renderizar las sombras

con volúmenes de sombras lo suficientemente rápido como para utilizarlas en aplicaciones de tiempo real, paso de profundidad, fallo en profundidad y OR exclusivo, pero todos ellos utilizan el mismo proceso:

-renderizar la escena como si estuviera completamente en sombra. - para cada punto de luz: -usar la información de profundidad de la escena para construir una

mascara en el stencil buffer que tiene huecos solo donde la superficie visible no es una sombra

-Renderizar la escena de nuevo como si estuviera completamente iluminada, usando el stencil buffer para la máscara de las áreas sombreadas.

Colores y sombras

78

La diferencia entre estos métodos ocurre en el segundo paso de la generación de la máscara. Unos requieren un paso, otros dos y requieren diferente nivel de precisión para el stencil buffer. 7.9.5.1 Paso de profundidad (Depth pass)

Heidemann propuso que si el frente de las superficies y la trasera de las sombras eran renderizadas en pasos separados, el número de caras frontales y traseras de un objeto puede ser contado usando el stencil buffer. Si la superficie de un objeto esta en sombra, habrá más superficies sombreadas frontalmente entre ella y el ojo que con las superficies traseras sombreadas. Si su número es igual, sin embargo, la superficie del objeto no es una sombra. 7.9.5.2 Error de Profundidad (Depth fail)

Sobre el 200 algunas personas descubrieron que el método de Heidmann puede trabajar desde cualquier punto de la cámara reinvirtiendo la profundidad. En vez de contar las caras frontales sombreadas de la superficie del objeto, las superficies traseras se pueden contar así fácilmente con el mismo resultado. Esto soluciona el problema de tener el observador en sombra, pero introduce la condición de que el extremo posterior del volumen de sombras debe ser encapsulado o las sombras terminarán perdiéndose donde los puntos del volumen van al infinito. 7.9.7.3 OR exclusivo

Las dos técnicas anteriores pueden aproximarse mediante la variación OR exclusivo, que no trata propiamente con la intersección de los volúmenes de sombras, pero ahorra un paso de renderización y solo requiere un bit de stencil buffer. 7.10 Fusión (Dithering)

Es una técnica usada para crear la ilusión de profundidad de color en imágenes con una paleta de colores limitada. En una imagen con fusión los colores no disponibles en la paleta original son aproximados por una difusión de los píxel coloreados dentro de la paleta disponible. El ojo humano percibe la difusión como una mezcla de colores.

Figura 64 Ejemplo fusión

Colores y sombras

79

Esta imagen está formada solo por rojo y azul, pero según se van haciendo mas pequeños los pixeles el ojo humano empieza a percibir un nuevo color mezcla de la aproximación de los dos presentes, con lo cual se puede percibir un color morado no presente en la paleta de colores inicial, pero la imagen sigue estando compuesta solo por rojo y azul.

Figura 65 Imagen sin fusión Figura 66 Imagen con fusión

Se puede obtener una buena calidad de imagen con aproximadamente 8 bits de R,G,B sin utilizar fusión. Sólo porque nuestra maquina tenga 24 planos de color no significa que la fusión no sea deseable. Por ejemplo, si estamos ejecutando en modo doble buffer, los planos de color pueden ser divididos en 2 conjuntos de 12, así tendremos sólo 4 bits para cada componente RGB. Sin fusión 4 bits por componente ofrecen resultados poco satisfactorios.

Figura 67 Incremento de difusión

Colores y sombras

80

Nota: La fusión al contrario que otras características está habilitada por defecto.

Se puede deshabilitar con glDisable(GL_DITHER). Y habilitar con glEnable( GL_DITHER ).

7.11. Creación de Paletas de Ventana

Podemos crear una paleta utilizando la función CreatePalette() e identificando la paleta mediante un indicador del tipo HPALETTE:

HPALETTE CreatePalette( CONST LOGPALETTE *lplgpl // puntero a la paleta

lógica de color ); Esta paleta utiliza una estructura lógica de paleta (LOGPALETE) que

contiene 256 entradas, especificando los 8 bits para las componentes R,G,B.

7.11.1 Arbitraje de paletas

En la publicidad del sistema Windows se afirma que su sistema operativo es multitarea, por lo tanto se debe permitir la ejecución simultanea de varias aplicaciones. Pero el hardware solo permite 256 colores en la paleta del sistema que deben ser compartidos por todas las aplicaciones en ejecución. Si alguna de las aplicaciones modifica la paleta del sistema puede que se altere la presentación de imágenes de otras aplicaciones produciendo efectos no deseados. Windows proporciona un conjunto de mensajes para arbitrar el uso de paletas entre varias aplicaciones. Por lo tanto si una aplicación modifica la paleta del sistema se notificará este cambio al resto de las aplicaciones en ejecución.

Cuando una aplicación se convierte en la aplicación activa Windows

envía el mensaje WM_QUERYNEWPALETTE a la ventana principal de la aplicación, preguntándole si desea copiar las entradas de su paleta privada en las entradas del sistema. En caso afirmativo la aplicación selecciona la paleta en el contexto de dispositivo para la ventana actualizada y llama después a RealizePalette().

Otro mensaje que puede enviar Windows para el arbitraje de las paletas

es WM_PALETTECHANGED que indica a la ventana que puede seleccionar la paleta, incluso si no es la ventana activa.

En el siguiente ejemplo mostramos la realización de este procedimiento: // Procedimiento de la ventana, gestiona todos los

mensaje de este programa LRESULT CALLBACK WndProc (HWND hWnd,UINT

message,WPARAM wParam,LPARAM lParam) ... // Windows le dice a la aplicación que puede

modificar la paleta del sistema.

Colores y sombras

81

// Es decir, este mensaje solicita una nueva palet a a la aplicación

case WM_QUERYNEWPALETTE: // Si la paleta fue creada if(hPalette) { int nRet; // Selecciona la paleta en el contexto

de dispositivo actual SelectPalette(hDC, hPalette, FALSE); //Correspondencia de entradas entre la

paleta actualmente // seleccionada y la paleta del

sistema. El valor devuelto es // el número de entradas de la paleta

modificada. nRet = RealizePalette(hDC); // Al redibujar se fuerza el

replanteado de la paleta // en la ventana actual InvalidateRect(hWnd,NULL,FALSE); return nRet; } break; // Esta ventana puede seleccionar la paleta,

incluso si no // es la ventana activa. case WM_PALETTECHANGED: // No hacer nada si la paleta no existe, o

si esta // es la ventana que cambio la paleta if((hPalette != NULL) && ((HWND)wParam !=

hWnd)) { // Selecciona la paleta en el contexto

de dispositivo SelectPalette(hDC,hPalette,FALSE); // Entrada en la paleta del sistema RealizePalette(hDC); // Reasigna los colores actuales a la

nueva paleta realizada UpdateColors(hDC); return 0; } break;}

Colores y sombras

82

7.11.2. Creación de una paleta.

Determinamos si nuestra aplicación necesita una paleta llamando a la función DescribePixelFormat() después de haber definido el formato de píxel. Se ha de comprobar el valor del miembro dwFlags de la estructura PÍXELFORMATDESCRIPTOR devuelto por DescribePixelFormat(), comprobaremos el valor del bit PFD_NEED_PALETTE, si estuviese activo tendríamos que crear una paleta para uso de la aplicación.

7.11.3 Estructura de la paleta.

Para crear una paleta reservaremos memoria para la estructura LOGPALETTE.

typedef struct tagLOGPALETTE { // lgpl WORD palVersion; WORD palNumEntries; PALETTEENTRY palPalEntry[1]; } LOGPALETTE;

La estructura se ha de completar con información sobre nuestra paleta y llamar a la función CreatePalette() pasándosela como argumento.

Cada entrada en la paleta es una estructura PALETTEENTRY definida

de la forma:

typedef struct tagPALETTEENTRY { // pe BYTE peRed; BYTE peGreen; BYTE peBlue; BYTE peFlags; } PALETTEENTRY;

- peRed, peGreen y peBlue representan las intensidades relativas para las componentes de 8 bits RGB. Así cada una de las 256 entradas de la paleta contendrá una definición de color de 24 bits.

- PeFlags se utiliza para especificar opciones avanzadas de la paleta. Normalmente su valor será NULL.

En el siguiente ejemplo mostramos la creación, arbitraje y estructura de

una paleta: // Selecciona el formato de píxel para un contexto de dispositivo void SetDCPixelFormat(HDC hDC) { int nPixelFormat; static PIXELFORMATDESCRIPTOR pfd = {

Colores y sombras

83

sizeof(PIXELFORMATDESCRIPTOR), // Tamaño de la estructura 1, // Version of this structure PFD_DRAW_TO_WINDOW | // Dibuja en la ventana (No en el mapa de bits) PFD_SUPPORT_OPENGL | // Soporta llamada OpenGL en la ventana PFD_DOUBLEBUFFER, // Modo de doble Buffer PFD_TYPE_RGBA, // Modo de color RGBA 24, // Pide 24 bits de color 0,0,0,0,0,0, // No se usa para seleccionar el modo 0,0, // No se usa para seleccionar el modo 0,0,0,0,0, // No se usa para seleccionar el modo 32, // Tamaño del Buffer de Profundidad 0, // No se usa para seleccionar el modo 0, // No se usa para seleccionar el modo PFD_MAIN_PLANE, // Dibuja en el plano principal 0, // No se usa para seleccionar el modo 0,0,0 }; // No se usa para seleccionar el modo // Escoge el formato de píxel que mejor encaje en los descrito por pfd nPixelFormat = ChoosePixelFormat(hDC, &pfd); // Selecciona el formato de píxel para el contexto de dispositivo SetPixelFormat(hDC, nPixelFormat, &pfd); } // Si es necesario, crea una paleta 3-3-2 para el c ontexto de dispositivo listado HPALETTE GetOpenGLPalette(HDC hDC) { HPALETTE hRetPal = NULL; // Indicador a la paleta que va a crear PIXELFORMATDESCRIPTOR pfd; // Descriptor del formato de píxel LOGPALETTE *pPal; // Puntero a memoria para la paleta lógica

Colores y sombras

84

int nPixelFormat; // índice del formato de píxel int nColors; // Numero de entradas en la paleta int i; // Variable de cuenta BYTE RedRange,GreenRange,BlueRange; // Rango para cada entrada de color (7,7,y 3) //Toma el formato de píxel y recupera la descripci ón del formato de píxel nPixelFormat = GetPixelFormat(hDC); DescribePixelFormat(hDC, nPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd); //¿Necesita una paleta este formato de píxel? Si n o, no crea una paleta // y devuelve NULL if(!(pfd.dwFlags & PFD_NEED_PALETTE)) return NULL; //Numero de entradas en la paleta. 8 bits abarcan 256 entradas nColors = 1 << pfd.cColorBits; //Reserva espacio para la estructura de la paleta lógica mas todas las entradas de paleta pPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +nColors*sizeof(PALETTEENTRY)); // Completa la cabecera de la paleta pPal->palVersion = 0x300; // Windows 3.0 pPal->palNumEntries = nColors; // Dimensiones de l a tabla //Crea una mascara de 1's. esto crea un numero representado por tener //activo los bits x de menor orden, donde x = pfd.cRedBits, //pfd.cGgreenBits y pfd.cBlueBits. RedRange = (1 << pfd.cRedBits) -1; GreenRange = (1 << pfd.cGreenBits) - 1; BlueRange = (1 << pfd.cBlueBits) -1; // Bucle a través de todas las entradas de paleta for(i = 0; i < nColors; i++) { // Completa las equivalencias de 8 bits para cada componente

Colores y sombras

85

pPal->palPalEntry[i].peRed = (i >> pfd.cRedShift) & RedRange; pPal->palPalEntry[i].peRed = (unsigned char)( (double) pPal->palPalEntry[i].peRed * 255.0 / RedRange); pPal->palPalEntry[i].peGreen = (i >> pfd.cGreenShift) & GreenRange; pPal->palPalEntry[i].peGreen = (unsigned char)( (double)pPal->palPalEntry[i].peGreen * 255.0 / GreenRange); pPal->palPalEntry[i].peBlue = (i >> pfd.cBlueShift) & BlueRange; pPal->palPalEntry[i].peBlue = (unsigned char)( (double)pPal->palPalEntry[i].peBlue * 255.0 / BlueRange); pPal->palPalEntry[i].peFlags = (unsigned char) NULL; } // Crea la paleta hRetPal = CreatePalette(pPal); // Avanza, selecciona y realiza la paleta para est e contexto de dispositivo SelectPalette(hDC,hRetPal,FALSE); RealizePalette(hDC); // Libera la memoria usada para la estructura lógi ca de paleta free(pPal); // Devuelve el indicador a la nueva paleta return hRetPal; } 7.11.4 Destrucción de una paleta.

Debemos crear y realizar la paleta antes de crear o activar el contexto de dispositivo.

En el siguiente ejemplo mostramos las operaciones necesarias para

crear y destruir una ventana teniendo en cuenta la posible existencia de una paleta // Procedimiento de la ventana, gestiona todos los mensaje de este programa

Colores y sombras

86

LRESULT CALLBACK WndProc( HWND hWnd,UINT message, WPARAM wParam, LPARAM lParam) { static HGLRC hRC; // Contexto de generación permanente static HDC hDC; // GDI privado del contexto de dispositivo switch (message) { // Creacion de ventana para OpenGL case WM_CREATE: // Almacena el contexto de dispositivo hDC = GetDC(hWnd); // Selecciona el formato de píxel SetDCPixelFormat(hDC); // Crea la paleta hPalette = GetOpenGLPalette(hDC); // Crea el contexto de generación y lo activa hRC = wglCreateContext(hDC); wglMakeCurrent(hDC, hRC); // Llamada a la función de iniciación de la aplicación Init(); break; // Se destruye la aplicación, hay que limpiar todo! case WM_DESTROY: // Desactiva el contexto de generación actual y lo borra wglMakeCurrent(hDC,NULL); wglDeleteContext(hRC); ReleaseDC(hWnd,hDC); // Borra la paleta si fue creada if(hPalette != NULL) DeleteObject(hPalette); // Le dice a la aplicación que termine después de que // se cierre la ventana PostQuitMessage(0); break ;

7.12 Conclusión

En este tema hemos aprendido qué es el color y el sombreado, cual es la naturaleza de la luz, como la percibe el ojo humano y algunos de los modelos que se utilizan para su representación.

Hemos visto la necesidad de introducir el sombreado o degradado de

color para obtener un resultado más realista en nuestras escenas. Se han introducido todas las funciones necesarias para establecer el

color de un objeto, el color con el que se limpia la pantalla, el modelo con el que se va a realizar el sombreado, la utilización de paletas y su gestión en OpenGL. Se han proporcionado ejemplos de aplicaciones que hacen uso de todas para facilitar su comprensión y posterior utilización.

7.13 Otras funciones para luces y sombras

glAccum

• Propósito: Opera en el buffer de acumulación para establecer los valores de

píxel.


• Sintaxis: void glAccum(GLenum func, GLfloat valor);

• Descripción: Esta función opera en el buffer de acumulación. A excepción de

GL_RETURN, los valores de color se escalan según el parámetro valor y

se añaden o suman al buffer de acumulación. En el caso de

GL_RETURN, los valores de color del buffer de acumulación se escalan

según el parámetro valor y se almacenan en el buffer de color actual.

• Parámetros:

func

GLenum: la función de acumulación aplicada. Las funciones válidas son las

siguientes:

GL_ACCUM: Añade valores de color escalados al buffer

de acumulación.

GL_LOAD: Abre valores de color escalados en el buffer

de acumulación, sustituyendo a los que hubiera antes.

GL_ADD: Añade un color constante a los valores del buffer

de acumulación.

GL_MULT: Multiplica los valores de color en el buffer

Colores y sombras

88

de acumulación por un valor constante.

GL_RETURN: Copia el buffer de acumulación en el buffer

de color principal.


glColorMask

• Propósito: Activa o desactiva la modificación de las componentes de color en

los buffers de color.


• Sintaxis: void glColorMask(GLboolean bRojo, GLboolean bVerde, GLboolean

bBlue, GLboolean bAlfa);

• Descripción: Esta función permite cambios individuales en las componentes

de color en el buffer de color para activarlas o desactivarlas.

• Parámetros:

bRojo

Glboolean: especifica cuándo se puede modificar la componente roja.

bVerde

Glboolean: especifica cuándo se puede modificar la componente verde.

bAzul

Glboolean: especifica cuándo se puede modificar la componente azul.

bAlfa

Glboolean: especifica cuándo se puede modificar la componente alfa.


glDrawBuffer

• Propósito: Selecciona un buffer de color para dibujar.


• Sintaxis: void glDrawBuffer(GLenum modo);

• Descripción: Esta función selecciona un buffer de color para las operaciones

de dibujo siguientes. Normalmente la usaremos para seleccionar el buffer

frontal u oculto en un contexto de dibujo con doble buffer.

• Parámetros:

modo

Glenum: una constante que selecciona el buffer de color en el que vamos a

trabajar. Puede ser un valor de la siguiente tabla.

Colores y sombras

89


Valor de modo Descripción

GL_NONE No se dibuja en ningún buffer de color.

GL_FRONT Dibujamos sólo en el buffer de color frontal (visible).

GL_BACK Dibujamos sólo en el buffer de color trasero (oculto).

GL_FRONT_AND_BACK Dibujamos en ambos buffers de color.

glFog

• Propósito: Especifica los parámetros de niebla.


• Sintaxis:

• void glFogf( GLenum pnombre, GLfloat params);

• void glFogfv( GLenum pnombre, GLfloat *params);

• void glFogi( GLenum pnombre, GLint params);

void glFogiv( GLenum pnombre, GLint *params);

• Descripción: Define los parámetros de niebla. Para dibujar usando niebla,

debemos hacer una llamada a glEnable(GL_FOG).

• Parámetros:

pnombre

Glenum: el parámetro definido. Los nombres válidos son los siguientes:

GL_FOG_COLOR: Color de la niebla.

GL_FOG_DENSITY: Densidad de la niebla.

GL_FOG_END: Distancia más alejada a la que se aplica niebla.

GL_FOG_INDEX: El índice de color usado para niebla si se está

en modo indexado.

GL_FOG_MODE: El tipo de niebla.

GL_FOG_START: La distancia más cercana a la que se aplica la

niebla.


Colores y sombras

90

glIndexMask

• Propósito: Evita la modificación de bits individuales del buffer de color.


• Sintaxis: void glIndexMask( GLuint mascara);

• Descripción: Esta función permite enmascarar bits individuales en el buffer

de color indexado. Cuando se activa el bit de máscara, los bits son

modificables; cuando son cero, están protegidos. Esta función sólo se aplica

al modo de color indexado.

• Parámetros:

mascara

GLuint: especifica la máscara binaria que activa o desactiva la escritura en los

bits individuales del buffer de color indexado.


glIsEnabled

• Propósito: Verifica si una función de OpenGL está activada.


• Sintaxis: Glboolean glIsEnabled(GLenum caract);

• Descripción: Devuelve GL_TRUE si la función especificada ha sido activada,

GL_FALSE en otro caso.

• Parámetros:

caract

GLenum: la función a verificar (ver glEnable).

• Retornos: GLboolean: GL_TRUE si la función está activada, GL_FALSE si

no.

glLogicOp

• Propósito: Selecciona la operación lógica para el modo de color indexado.


• Sintaxis: void glLogicOp( GLenum opcode);

• Descripción: La operación lógica de píxel define la combinación de valores

de píxel. Cuando se especifica un nuevo valor de índice de color para una

Colores y sombras

91

localización de píxel, se combina lógicamente con el valor del índice de color

actual de ese píxel.

• Parámetros:

opcode

GLenum: especifica el modo lógico de píxel que hay que usar. Son válidos:

GL_CLEAR, GL_SET, GL_COPY, GL_COPY_INVERTED, GL_NOOP,

GL_INVERT, GL_AND, GL_NAND, GL_OR, GL_NOR, GL_XOR, GL_ EQUIV,

GL_AND_REVERSE, GL_AND_INVERTED, GL_OR_REVERSE y

GL_OR_INVERTED.


glPolygonMode

• Propósito: Selecciona el modo en que se generan los polígonos.


• Sintaxis: void glPolygonMode(Glenum cara, GLenum modo);

• Descripción: Esta función nos permite cambiar la forma en que se generan

los polígonos. Por defecto, los polígonos se rellenan o sombrean con el color

o las propiedades de material actuales. Sin embargo, podemos especificar

que se dibujen sólo los perfiles o los vértices.

• Parámetros:

cara

GLenum: especifica a qué cara de los polígonos afecta el cambio de modo:

GL_FRONT, GL_BACK, GL_FRONT_AND_BACK.

modo

GLenum: especifica el nuevo modo de dibujo. El valor por defecto es GL_FILL,

que produce polígonos sólidos. GL_LINE produce perfiles de polígonos y

GL_POINT sólo traza los puntos de los vértices. La bandera de borde activada

por glEdgeFlag afecta a las líneas y puntos dibujados con GL_LINE y

GL_POINT.


Colores y sombras

92

7.14 Bibliografia

"Gráficas por Computador"

Autor: Hearn, Baker

Ed: Prentice Hall

"Computer Graphics: Systems&Concepts"

Autor: Salmon, Slater

Ed: Addison

"Introduction to the GKS"

Autor: Hopgood, Duce

Ed: Academic Press, 86

“Introduction to Computer Graphics”

Autor: Foley, Van Dam

Ed: Addison-Wesley

“Visual Cues”

Autor: Keller

Ed: IEEE, 1993

"Three Dimensional Computer Graphics"

Autor: Watt

Ed: Addison

"Mathematical Elements for Computer Graphics"

Autor: Rogers, Adams

Ed: McGraw

"Curves and Surfaces in Computer Aided Geometric Design"

Autor: Yamaguchi

Ed: Springer

“Interactive Computer Graphics: A Top-Down Approach with OpenGL”

Autor: Angel

Ed: Addison Wesley, 1997

“Computer Graphics 2/e”

Autor: Hearn

Ed: Prentice Hall

“3D Computer Graphics, 2/e”

Autor: Watt

Ed: Addison Wesley

Colores y sombras

93

“Introduction to Computer Graphics”

Autor: Foley

Ed: Addison Wesley

“OpenGL Programming Guide & Reference Manual”

Autor: Varios

Ed: Addison Wesley

“Inventor Mentor & Toolmaker”

Autor: Varios

Ed: Addison Wesley

“SIGGRAPH '98 Conference Proceedings”

Autor: Varios

Ed: Addison Wesley

Opengl Architecture Review Board, “OpenGL Reference Manual, The Official

Reference Document to OpenGL, Version 1.2 “

Autor: Dave Shreiner

“OpenGL SuperBible, Second Edition (SuperBible)”

Autor: Richard S. Wright Jr., Richard S., Jr. Wright

“OpenGL Programming for the X Window System”

Autor: Mark J. Kilgard

“Computer Graphics : Principles and Practice, Second Edition in C by”

Autor: James D. Foley

OpenGL Architecture Review Board, “OpenGL(r) 1.2 Programming Guide

Autor: Mason Woo, Jackie Neider, Tom Davis, Dave Shreiner

OpenGL Architecture Review Board, “OpenGL(r) 1.2 Programming Guide

Autor: Mason Woo, Jackie Neider, Tom Davis, Dave Shreiner

"COMPUTER GRAPHICS: An object-oriented approach to the art and science"

Autor: Cornel Pokorny

Ed: Franklin, Beedle & Associates Incorporated

Colores y sombras

94

"COMPUTER GRAPHICS: C version" (2nd. ed. o posterior)

Autores: Donald Hearn and M. Pauline Baker

Ed: Prentice Hall

"COMPUTER GRAPHICS: Principles and practice (C version)"

Autores: J. Foley, A. van Dam, S.K. Feiner and J.F. Hughes

Ed: Addison-Wesley Publishing Company

"COMPUTER GRAPHICS"

Autor: F.S. Hill Jr.

Ed: Macmillan Publishing Co.

"Interactive Computer Graphics: a top-down approach with OpenGL"

Autor: E. Angel

Ed: Addison-Wesley Publishing Company, 1997

"Mathematical Elements for Computer Graphics"

Autores: D.F.Rogers and J.A.Adams

Ed: McGraw Hill, 1.976.

"Principles of Interactive Computer Graphics"

Autores: W. Newman and R. Sproull

Ed: McGraw Hill, 1979.

"Raster Graphics Handbook, Conrac Division, 2nd edition"

Ed: Van Nostrand Reinhold Co., 1.984.

"The Mathematical Structure of Raster Graphics"

Autores: Eugene L. Fiume

Ed: Academic Press, Inc., 1986.

"Windows NT OpenGL: Getting Started."

Autores: Crain, Dennis

Ed: MSDN Library, Technical Articles

OpenGL Programming Guide: The Official Guide to Learning OpenGL, Release 1

Autores: Neider, Jackie, Tom Davis, and Mason Woo

Ed: Addison-Wesley

“Principles of Digital Image Synthesis”

Autores: Glassner

Ed: Morgan Kaufmann Publisher, 1995.

Colores y sombras

95

Computer Graphics: Principles and Practice (2nd. Ed. in C)

Autores: Foley, van Dam, Feiner, Hughes

Ed: Addison-Wesley Publishing Company, 1993.

Radiosity and Realistic Image Synthesis

Autores: Cohen, Wallace

Ed: Academic Press, 1993.

Computer Graphics Proceedings. Annual Conference Series.

Autores: Varios

Ed: ACM SIGGRAPH (ACM Special Interest Group on Computer Graphics).

Rendering Techniques (Proceedings del EG Workshop on Rendering)

Autores: Varios

Ed: Springer Verlag, años 1994 hasta 1999

OpenGL Architecture Review Board. OpenGL Reference Manual: The Official

Reference Document for OpenGL, Release 1. Reading, MA

Autores: Varios

Ed: Addison-Wesley, 1992

"Advanced 3-D Graphics for Windows NT 3.5: Introducing the OpenGL Interface, Part

I." Microsoft Systems Journal 9 (October 1994)

Autores: Prosise, Jeff

Ed: MSDN Library Archive Edition, Books and Periodicals)

"Advanced 3-D Graphics for Windows NT 3.5: The OpenGL Interface, Part II."

Microsoft Systems Journal 9 (November 1994)

Autores: Prosise, Jeff

Ed: MSDN Library Archive Edition, Books and Periodicals)

"OpenGL I: Quick Start."

Autores: Rogerson, Dale

Ed: (MSDN Library, Technical Articles)

Colores y sombras

96

"OpenGL II: Windows Palettes in RGBA Mode."



"OpenGL III: Building an OpenGL C++ Class."



Using DIBs with Palettes. Autores: Gery, Ron Ed: (MSDN Library, Technical Articles)

7.15 Enlaces de interés

http://cannes.itam.mx/Alfredo/Espaniol/Cursos/Grafica/Sombreado.pdf http://en.wikipedia.org/ http://www.opengl.org/ http://www.dsic.upv.es/users/sig/personales/ramon/esp/GrafInternet.html http://www.ii.uam.es/~pedro/graficos/teoria/index.html http://m3d.uib.es/grafica2/Ejemplos.html http://serdis.dis.ulpgc.es/~atrujill/iga/Practicas2000.htm http://sgio2.cem.itesm.mx/rudomin/graf99/curso.htm http://victoryrocio.datablocks.net/i/opengl/ http://www.codexmx.com/macedonia/opengl2.htm http://www.ldc.usb.ve/~jhony/graficasII/p1/informe1.html http://www.salleurl.edu/CITeM/grafics/recursos/arxius/cap3.pdf http://www2.ing.puc.cl/~iic1222/glex http://giig.ugr.es/~cadii/Doc/Articulo http://trant.sgi.com/opengl/examples/redbook/redbook.html

Colores y sombras

97

http://www.eecs.tulane.edu/www/graphics/doc/OpenGL-Man-Pages/index.html http://giig.ugr.es/~curena/doce/docto/ http://odra.dcs.fi.uva.es/area2/opengl/colorysombra.html http://odra.dcs.fi.uva.es/area2/opengl/refgl.html http://giig.ugr.es/~curena/doce/vr/transparencias/

Documents

Tema07