Tema 4 Imágenes y texturas - UHUuhu.es/francisco.moreno/gii_vg/docs/Tema_4.pdf · 2015. 10. 1. ·...

Departamento de Tecnologías de la Información

Ciencias de la Computación e Inteligencia Artificial

Tema 4

Imágenes y texturas

Tema 4. Imágenes y texturas

Visualización Gráfica

Índice

4.1 Bitmaps

4.2 Pixmaps

4.3 Transformaciones de imágenes

4.4 Definición de texturas

4.5 Aplicación de texturas

4.6 Mipmaps

4.7 Compresión de texturas

4.8 Generación de coordenadas

2



Índice

4.1 Bitmaps

4.2 Pixmaps




4.6 Mipmaps



3



4.1 Bitmaps

• Un bitmap es una matriz de bits que representan una imagen cuyos

píxeles pueden estar en dos estados: on y off.

• Los bitmaps se utilizan como para representar máscaras (stippling) o

fuentes de letra.

• Para dibujar un bitmap sobre la imagen se utiliza:

glBitmap(width,height,xorig,yorig,xmove,ymove,bitmap);

• Donde width y height describen el tamaño del bitmap, xorig e yorig la

posición de la esquina inferior izquierda, xmove e ymove el

desplazamiento a realizar sobre la posición raster y bitmap es un

array de GLubyte.

4



GLubyte fly[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60, 0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20, 0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20, 0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22, 0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xCC, 0x19, 0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83, 0x30, 0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0, 0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0, 0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30, 0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08, 0x10, 0x63, 0xC6, 0x08, 0x10, 0x30, 0x0c, 0x08, 0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08};

4.1 Bitmaps

5



4.1 Bitmaps

• Los bitmaps se dibujan sobre la imagen a partir de una posición

llamada posición raster.

• Para fijar la posición raster se utiliza la función glRasterPos..(). En

esta función las coordenadas se interpretan como coordenadas de

vértices y, por tanto, son transformadas por las matrices modelview

y projection. Este es un ejemplo de la funcion

glRasterPos2i(0,0);

• Para fijar la posición raster en coordenadas de la ventana se utiliza la

función

glWindowPos2i(0,0);

6



Índice

4.1 Bitmaps

4.2 Pixmaps




4.6 Mipmaps



7



4.2 Pixmaps

• Un pixmap es una matriz de píxeles que representan una imagen.

• Los valores de los píxeles pueden estar descritos en varios formatos

y almacenados en distintos tipos de datos.

• Para dibujar un bitmap sobre la imagen se utiliza:

glDrawPixels( width, height, format, type, pixels);

• Donde width y height describen el tamaño del pixmap, format indica

el formato en que se describen los valors de los píxeles, type es el

tipo de dato utilizado para almacenar el valor de cada pixel y pixels

es un array del tipo indicado anteriormente.

• Los pixmaps se dibujan en la posición raster. 8



4.2 Pixmaps

Formatos admitidos

9

GL_COLOR_INDEX GL_STENCIL_INDEX

GL_DEPTH_COMPONENT GL_RGB

GL_BGR GL_RGBA

GL_BGRA GL_RED

GL_GREEN GL_BLUE

GL_ALPHA GL_LUMINANCE

GL_LUMINANCE_ALPHA



4.2 Pixmaps

10

Tipos de dato admitidos

•

•

•

•

Tipo Contenido

GL_UNSIGNED_BYTE unsigned 8-bit integer

GL_BYTE signed 8-bit integer

GL_BITMAP single bits in unsigned 8-bit integers

GL_UNSIGNED_SHORT unsigned 16-bit integer

GL_SHORT signed 16-bit integer

GL_UNSIGNED_INT unsigned 32-bit integer

GL_INT 32-bit integer

GL_FLOAT single-precision floating-point

GL_UNSIGNED_BYTE_3_3_2 unsigned 8-bit integer

GL_UNSIGNED_BYTE_2_3_3_REV unsigned 8-bit integer with reversed component ordering

GL_UNSIGNED_SHORT_5_6_5 unsigned 16-bit integer

GL_UNSIGNED_SHORT_5_6_5_REV unsigned 16-bit integer with reversed component ordering



4.2 Pixmaps

11

Tipos de dato admitidos (continuación)

•

•

•

•

Tipo Contenido

GL_UNSIGNED_SHORT_4_4_4_4 unsigned 16-bit integer

GL_UNSIGNED_SHORT_4_4_4_4_REV unsigned 16-bit integer with reversed component ordering

GL_UNSIGNED_SHORT_5_5_5_1 unsigned 16-bit integer

GL_UNSIGNED_SHORT_1_5_5_5_REV unsigned 16-bit integer with reversed component ordering

GL_UNSIGNED_INT_8_8_8_8 unsigned 32-bit integer

GL_UNSIGNED_INT_8_8_8_8_REV unsigned 32-bit integer with reversed component ordering

GL_UNSIGNED_INT_10_10_10_2 unsigned 32-bit integer

GL_UNSIGNED_INT_2_10_10_10_REV unsigned 32-bit integer with reversed component ordering



4.2 Pixmaps

• OpenGL no contiene funciones para leer imágenes a partir de

ficheros en formatos estándar (GIF, PNG, JPEG, …). Es

responsabilidad del programador obtener la representación de las

imágenes como vectores de píxeles.

• Existen bibliotecas de libre distribución que permiten generar

pixmaps a partir de ficheros en formatos estándar, por ejemplo,

FreeImage.

12



4.2 Pixmaps

• Los pixmaps también se pueden leer del color buffer, obteniendo

una captura de la imagen generada por OpenGL.

glReadPixels(x, y, width, height, format, type, pixels);

• También se puede copiar un pixmap de una zona del color buffer a

otra.

glCopyPixels(x,y,width,height,type);

• En este caso, la posición de destino es la asignada como posición

raster. El valor de type puede ser GL_COLOR, GL_DEPTH o

GL_STENCIL indicando si los datos a copiar son los valores

almacenados en el color buffer, el depth buffer o el stencil buffer.

13



4.2 Pixmaps

• Se puede especificar cual es el buffer de color del que van a tomar

los datos las funciones glReadPixels() y glCopyPixels().

glReadBuffer(GLenum mode);

• Los valores de mode pueden ser los siguientes: GL_FRONT_LEFT,

GL_FRONT_RIGHT, GL_BACK_LEFT, GL_BACK_RIGHT,

GL_FRONT, GL_BACK, GL_LEFT, GL_RIGHT y

GL_AUXi (donde i es un número entre 0 y GL_AUX_BUFFERS-1).

• Cuando se utiliza doble buffer, front se refiere al buffer mostrado y

back se refiere al buffer de trabajo. Las opciones left y right se refieren

a configuraciones de imágenes estereoscópicas.

• Para doble buffer y visión no estereoscópica el valor por defecto es

GL_BACK. 14



4.2 Pixmaps

• También se puede especificar cual es el buffer de color de destino de

las funciones glDrawPixels() y glCopyPixels().

glDrawBuffer(GLenum mode);

• Los valores admitidos para mode son los mismos que los utilizados

en la función glReadBuffer().

15



Índice

4.1 Bitmaps

4.2 Pixmaps




4.6 Mipmaps



16




• Se pueden configurar transformaciones sobre las imágenes a

mostrar con glDrawPixels() y glCopyPixels().

• Por ejemplo, se puede escalar la imagen en dirección X e Y.

glPixelZoom(GLfloat xfactor, Glfloat yfactor);

• También se pueden realizar transformaciones de color por medio de

la función

glPixelTransferi(GLenum type, GLint param);

glPixelTransferf(GLenum type, GLfloat param);

17




• Los valores admitidos para el tipo de transformación son:

• Los valores scale y bias describen una transformación lineal de cada

color .

ColorFinal = ColorInicial * scale + bias

18

GL_RED_SCALE GL_RED_BIAS

GL_GREEN_SCALE GL_GREEN_BIAS

GL_BLUE_SCALE GL_BLUE_BIAS

GL_ALPHA_SCALE GL_ALPHA_BIAS

GL_DEPTH_SCALE GL_DEPTH_BIAS

GL_MAP_COLOR GL_MAP_STENCIL

GL_INDEX_SHIFT GL_INDEX_OFFSET




• La opción GL_MAP_COLOR sirve para modificar los colores de los

pixels por una índice a una tabla de colores. Para poder realizar esta

transformación es necesario definir la tabla de colores.

glPixelMapuiv(GLenum map, GLint mapsize, GLuint *values);

glPixelMapusv(GLenum map, GLint mapsize, GLushort *values);

glPixelMapfv(GLenum map, GLint mapsize, GLfloat *values);

• Se utiliza un mapa diferente para cada componente. El parámetro

map indica que mapa de qué componente se está configurando. Los

valores aceptados son:

19

GL_PIXEL_MAP_R_TO_R GL_PIXEL_MAP_G_TO_G

GL_PIXEL_MAP_B_TO_B GL_PIXEL_MAP_A_TO_A




• También se pueden aplicar filtros de convolución sobre las

imágenes.

• En primer lugar hay que activar la opción

glEnable(GL_CONVOLUTION_2D);

• A continuación se define el filtro de convolución:

glConvolutionFilter2D(GLenum target,

GLenum internalformat,

GLsizei width,

GLsizei height,

GLenum format,

GLenum type,

const GLvoid * data);

20




• target es siempre GL_CONVOLUTION_2D,

• internalFormat indica a que píxeles se les va a aplicar,

• width y height son el tamaño del filtro,

• format y type describen la forma en la que se almacena el filtro

• image contiene un array que describe el filtro.

21




• Ejemplo de filtro de convolución:

22

GLfloat filter[3][3] = { { 0.0f, -1.0f, 0.0f}, {-1.0f, 5.0f, -1.0f}, { 0.0f, -1.0f, 0.0f} }; glConvolutionFilter2D(GL_CONVOLUTION_2D, GL_RGB, 3, 3, GL_LUMINANCE, GL_FLOAT, filter); glEnable(GL_CONVOLUTION_2D); glDrawPixels( … );



Índice

4.1 Bitmaps

4.2 Pixmaps




4.6 Mipmaps



23




• Se denomina textura a la aplicación de una imagen a una primitiva

geométrica.

• Los puntos de las texturas se denominan texels.

• Tipos de texturas: 1D, 2D, 3D

– Texturas 1D: vector de texels en una dimensión (línea de texels)

– Texturas 2D: matriz de texels (imagen en 2 dimensiones)

– Texturas 3D: matriz de tres dimensiones (colección de imágenes o

volumen de texels)

• OpenGL identifica el tipo de textura mediante las constantes

GL_TEXTURE_1D, GL_TEXTURE_2D y GL_TEXTURE_3D.

24




• Para cargar una textura 1D en memoria se utiliza la función

glTexImage1D( GLenum target,

GLint level,

GLint internalFormat,

GLsizei width,

GLint border,

GLenum format,

GLenum type,


25






GLint level,


GLsizei width,

Glsizei height,

GLint border,

GLenum format,

GLenum type,


26






GLint level,


GLsizei width,

GLsizei height,

GLsizei depth,

GLint border,

GLenum format,

GLenum type,


27




• Los valores de target indican el tipo de textura que se está cargando.

• El parámetro level indica el nivel de “mipmap” de la textura cargada

(valor 0 por defecto).

• El parámetro internalFormat indica el formato en el que se va a

almacenar la textura. Los más comunes son GL_ALPHA,

GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB y

GL_RGBA. También pueden indicarse formatos comprimidos.

• Los parámetros width, height y depth indican el tamaño de la textura.

En las versiones anteriores a OpenGL 2.0 se exigía que fueran

potencias de 2 (1,2, 4, 8, 16, 32, 64, …). En versiones posteriores no se

exige, aunque es aconsejable.

28




• El parámetro border indica el número de texels de borde. El borde se

entiende como una extensión de la textura. Estos texels resultan

necesarios para evaluar los píxeles asociados a los extremos de las

texturas.

• Los parámetros format, type y data son idénticos a los utilizados para

definir pixmaps.

29




• Además de almacenarlas directamente, las imágenes que forman las

texturas se pueden copiar del color buffer

glCopyTexImage1D(GLenum target, GLint level,


GLint x, GLint y,

GLsizei width, GLint border);

glCopyTexImage2D(GLenum target, GLint level,


GLint x, GLint y,

GLsizei width, GLsizei height,GLint border);

• Donde x e y indican la posición del color buffer desde la que se

copia. El buffer utilizado es el indicado con glReadBuffer(). 30




• Cargar texturas es un proceso lento. En ocasiones conviene cargar solo

un trozo de textura sobre la textura ya existente en vez de realizar una

carga completa.

glTexSubImage1D(GLenum target, GLint level,

GLint xOffset, GLsizei width,

GLenum format, GLenum type, const GLvoid * data);


GLint xOffset, GLint yOffset,

GLsizei width, GLsizei height,


31





GLint xOffset, GLint yOffset, GLint zOffset,

GLsizei width, GLsizei height, GLsizei depth,


• Los valores de xOffset, yOffset y zOffset indican la posición en la que

comienza la susitución de la textura existente.

32




• También se puede sustituir las texturas con valores tomados desde el

color buffer:

glCopyTexSubImage1D(GLenum target, GLint level,

GLint xOffset,

GLint x, GLint y,

GLsizei width);


GLint xOffset, GLint yOffset,

GLint x, GLint y,

GLsizei width, GLsizei height);

33





GLint xOffset, GLint yOffset, GLint zOffset,

GLint x, GLint y,

GLsizei width, GLsizei height);

• En el caso de las texturas 3D, la copia de la imagen del color buffer se

hace en un único nivel de profundidad marcado por zOffset.

34




• Las funciones de OpenGL trabajan sobre la textura activa.

• Para trabajar sobre varias texturas sin necesidad de sobreescribir

constantemente la textura activa se definen objetos textura. Cada

objeto textura se identifica mediante un número.

• Para reservar identificadores de objetos textura se utiliza

glGenTextures(GLsizei n, GLuint* textures);

• Donde n es el número se identificadores a reservar y textures el

vector que almacena los identificadores.

• Para saber si un identificador está reservado como textura se utiliza

glIsTexture(GLuint texture);

35




• Para indicar cual de los objetos textura corresponde a la textura

activa se utiliza

glBindTexture(GLenum target, GLuint texture);

• Donde target indica el tipo de textura (GL_TEXTURE_1D,

GL_TEXTURE_2D o GL_TEXTURE_3D) y texture el identificador de

la textura a activar.

• Para eliminar las texturas se utiliza

glDeleteTextures(GLsizei n, GLuint* textures);

• Para configurar un objeto textura hay que activarlo con

glBindTexture() y operar con las funciones ya conocidas.

36



Índice

4.1 Bitmaps

4.2 Pixmaps




4.6 Mipmaps



37




• Para comenzar a utilizar texturas es necesario habilitar la opción

glEnable(GL_TEXTURE_1D);



• En cada momento solo puede estar activo un tipo de textura.

• De igual forma, se puede deshabilitar el uso de texturas con la

función glDisable(…).

glDisable(GL_TEXTURE_1D);



38




• Para identificar un punto en una textura se utilizan coordenadas.

OpenGL las denomina (s,t,r,q) con un significado similar a las

coordenadas espaciales (q es un factor de escala). Generalmente se

utilizan valores en coma flotante, entre 0.0f y 1.0f.

• La coordenada de la textura es una información asociada a los

vértices. Para asignarla se utilizan las funciones glTexCoord…().

glTexCoord1f(GLfloat s);

glTexCoord2f(GLfloat s, GLfloat t);

glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);

glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);

39




• Las coordenadas de las texturas pueden ser transformadas

multiplicándolas por la matriz GL_TEXTURE, de la misma forma

que las coordenadas de los vértices se transforman con las matrices

modelview y projection.

• Para modificar esta matriz se utilizan los funciones de manejo de

matrices. Para que estas funciones se apliquen a la matriz de

texturas hay que indicar glMatrixMode(GL_TEXTURE).

• También existe una pila de matrices de texturas, pero sólo puede

almacenar dos elementos. Esto permite utilizar glPushMatrix() y

glPopMatrix(), pero solo con un nivel de profundidad.

40




• El proceso de aplicación de texturas puede configurarse de muchas

formas. Para ello se utilizan dos funciones: glTexParameter..(), que

permite modificar algunos parámetros del proceso de aplicación de

texturas, y glTexEnv..(), que permite configurar el entorno de

texturas.

41




• La función glTexParameter..() tiene las siguientes versiones

glTexParameterf( GLenum target, GLenum pname, GLfloat param);

glTexParameteri( GLenum target, GLenum pname, GLint param);

glTexParameterfv( GLenum target, GLenum pname, Glfloat* param);

glTexParameteriv( GLenum target, GLenum pname, Glint* param);

• target indica el tipo de textura (GL_TEXTURE_1D, …).

• pname indica el parámetro a configurar.

• param indica el valor asignado al parámetro.

42




• pname puede ser

43

GL_TEXTURE_MIN_FILTER GL_TEXTURE_MAG_FILTER

GL_TEXTURE_BASE_LEVEL GL_TEXTURE_MAX_LEVEL

GL_TEXTURE_MIN_LOD GL_TEXTURE_MAX_LOD

GL_TEXTURE_LOD_BIAS GL_TEXTURE_WRAP_S

GL_TEXTURE_WRAP_T GL_TEXTURE_WRAP_R

GL_TEXTURE_COMPARE_FUNC GL_TEXTURE_COMPARE_MODE

GL_TEXTURE_SWIZZLE_R GL_TEXTURE_SWIZZLE_G

GL_TEXTURE_SWIZZLE_B GL_TEXTURE_SWIZZLE_A

GL_DEPTH_STENCIL_TEXTURE_MODE




• La función glTexEnv..() tiene estos formatos

glTexEnvi(GLenum target, GLenum pname, GLint param);

glTexEnvf(GLenum target, GLenum pname, GLfloat param);

• target indica el entorno de textura a configurar (GL_TEXTURE_ENV,

GL_TEXTURE_FILTER_CONTROL o GL_POINT_SPRITE).

• pname indica el parámetro del entorno a configurar.

• param indica el valor asignado al parámetro

44




• Cuando target es GL_TEXTURE_ENV, pname puede ser

45

GL_TEXTURE_ENV_MODE GL_TEXTURE_ENV_COLOR

GL_COMBINE_RGB GL_COMBINE_ALPHA

GL_RGB_SCALE GL_ALPHA_SCALE

GL_SRC0_RGB GL_SRC1_RGB

GL_SRC2_RGB GL_SRC0_ALPHA

GL_SRC1_ALPHA GL_SRC2_ALPHA




• Para aplicar una textura sobre una primitiva geométrica se calculan

las coordenadas de textura correspondientes a cada pixel de la

primitiva y se busca en la textura el color correspondiente a esas

coordenadas. Esto se conoce como texture-filtering.

• Típicamente, el tamaño de la textura y el tamaño de la primitiva

serán diferentes y al filtrar tendremos que agrandar la textura o

encogerla.

• OpenGL define formas de filtrado independientes para agrandar o

encoger las texturas.

46




• Para configurar el proceso de filtrado se utiliza la función

glTexParameter…() con los parámetros GL_TEXTURE_MAG_FILTER y

GL_TEXTURE_MIN_FILTER.

• Los valores típicos para los filtros son GL_NEAREST y GL_LINEAR.

• El filtro GL_NEAREST se limita a asignar al pixel el color del texel más

cercano a sus coordenadas de textura. Este filtro puede provocar

problemas de aliasing. El filtro GL_LINEAR realiza una interpolación

lineal entre los cuatro texels vecinos.

47




• Cuando la primitiva geométrica se observa de manera inclinada, el

filtrado lineal (aunque mejor que el nearest) produce un efecto

borroso. Eso se debe a que la distancia de los texels se ve afectada por

el efecto de la inclinación.

• Para considerar este efecto se puede configurar un filtrado

anisotrópico. En realidad esta opción no forma parte del estandar de

OpenGL, pero la mayoría de los fabricantes la añaden como extensión.

48




• Para activar el filtrado anisotrópico hay que verificar que la opción

esté soportada y a continuación modificar el nivel de anisotropía del

filtrado con el parámetro GL_TEXTURE_MAX_ANISOTROPY_EXT.

49

if(gltIsExtSupported(“GL_EXT_texture_filter_anisotropic”))

{

GLfloat fLargest;

glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fLargest);

glTexParameterf(GL_TEXTURE_2D,

GL_TEXTURE_MAX_ANISOTROPY_EXT, fLargest);

}




• Las texturas se dimensionan entre 0.0f y 1.0f. Sin embargo, las

coordenadas de textura no tienen por qué estar incluidas entre estos

límites. Esto puede ocurrir al utilizar la opción GL_LINEAR o al

colocar estos valores con glTexCoord..().

• El comportamiento de los filtros de textura más allá de los límites se

denomina texture wrapping. OpenGL permite configurar

comportamientos diferentes en cada dimensión.

• Para configurarlos se utilizan los parámetros GL_TEXTURE_WRAP_S,

GL_TEXTURE_WRAP_T y GL_TEXTURE_WRAP_R.

50




• Los valores de estos parámetros pueden ser: GL_REPEAT,

GL_CLAMP, GL_CLAMP_TO_EDGE o GL_CLAMP_TO_BORDER.

– GL_REPEAT genera una repetición de la textura.

– GL_CLAMP utiliza los texels del borde (si está definido) o el color del

borde. El color del borde se puede asignar con el parámetro

GL_TEXTURE_BORDER_COLOR.

– GL_CLAMP_TO_EDGE utiliza los texels de los extremos, es decir, repite el

último texel en cada dimensión.

– GL_CLAMP_TO_BORDER utiliza los texels del borde.

51




• El color final de cada pixel se construye utilizando las propiedades

de color (o material) y la textura. La forma de combinar estas

propiedades se controla configurando el entorno de textura

(GL_TEXTURE_ENV) por medio de la función glTexEnv().

• El parámetro GL_TEXT_ENV_MODE permite configurar el modo

en el que se va a combinar la textura con el color de la primitiva (que

ya contiene los efectos de iluminación).

52




53

GL_ADD obtiene el color final sumando la textura y el material

GL_MODULATE obtiene el color final multiplicando la textura y el

material

GL_DECAL mezcla los colores considerarndo el valor alpha de la

textura

GL_BLEND mezcla los colores considerando los valores del

parámetro de color de la textura

(GL_TEXTURE_ENV_COLOR)

GL_REPLACE utiliza solo el color de la textura

• Los valores posibles son




• La forma más habitual de combinar los efectos de la iluminación con

la textura es GL_MODULATE.

• Esta opción tiene como efecto no deseado que anula las luces

especulares, que aumentan la luminosidad del objeto. Esto se debe a

que no se puede aumentar la luminosidad mediante la

multiplicación por un número menor de 1.0.

• Para resolver este problema hay que tratar la luz especular después

de aplicar la textura.

glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,

GL_SEPARATE_SPECULAR_COLOR);

• Se puede volver al modo normal con el valor GL_COLOR_SINGLE.

54



Índice

4.1 Bitmaps

4.2 Pixmaps




4.6 Mipmaps



55



4.6 Mipmaps

• Cuando la primitiva geométrica resulta mucho más pequeña que el

tamaño de la textura se produce un efecto llamado scintillation. El

problema es que si el fragmento es pequeño, dos píxeles consecutivos

pueden corresponder a texels alejados y el filtrado provoca efectos de

aliasing. Este defecto resulta más visible cuando los objetos se

encuentran en movimiento.

• Para evitar este problema se utilizan mipmaps. El término mip procede

de la expresión latina “multum in parvo” (mucho en poco). La técnica

consiste en tener versiones de la textura de tamaños inferiores y

aplicar en cada caso el nivel de mipmap adecuado al tamaño del

fragmento.

• Cada nivel de mipmap se obtiene dividiendo entre dos cada

dimensión de la textura.

56



4.6 Mipmaps

• Cada nivel de mipmap se obtiene dividiendo entre dos cada

dimensión de la textura del nivel anterior.

• Por ejemplo, si tenemos una textura de 32x16, el nivel 1 tendría un

tamaño 16x8, el nivel 2 sería 8x4, el nivel 3 sería 4x2, el nivel 4 sería 2x1

y el nivel 5 sería 1x1. (Esta es la razón por la que los tamaños deben ser

potencias de 2)

• El mipmapping supone un gasto adicional en memoria. Para texturas

1D la memoria aumenta un 100%. Para texturas 2D la memoria

necesaria es un 33% mayor. Para texturas 3D el aumento es de un 15%.

• Los mipmaps se cargan con la funciones glTexImage..() y derivadas,

indicando el nivel de mipmap en el argumento level.

57



4.6 Mipmaps

• Por defecto, para utilizar mipmapping es necesario que todos los

niveles de mipmap estén cargados. Se puede indicar un rango de

niveles de mipmap obligatorios con los parámetros de textura

GL_TEXTURE_BASE_LEVEL y GL_TEXTURE_MAX_LEVEL.

• Por ejemplo, para configurar un mipmapping con los niveles

obligatorios de 0 a 4.

glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL , 0);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4);

• También se puede configurar los niveles de mipmap (level of detail) que

van a ser utilizados realmente con los parámetros

GL_TEXTURE_MIN_LOD y GL_TEXTURE_MAX_LOD. 58



4.6 Mipmaps

• El uso de mipmaps añade un nuevo aspecto a las opciones de filtrado.

Al considerar las componentes de textura de un pixel podemos

encontrarnos entre dos niveles de mipmap. En este caso podemos

calcular el color final de la textura con el mipmap más cercano o con

una interpolación lineal entre los dos mipmaps.

• Las opciones de filtrado pueden ser entonces

59

GL_NEAREST GL_LINEAR

GL_NEAREST_MIPMAP_NEAREST GL_LINEAR_MIPMAP_NEAREST

GL_NEAREST_MIPMAP_LINEAR GL_LINEAR_MIPMAP_LINEAR



4.6 Mipmaps

• Para utilizar mipmaps es necesario generar la imagen correspondiente

a cada nivel. Esto puede realizarse con alguna herramienta de edición

de imágenes y cargarse con glTexImage() o generarse de forma

automática.

• Una forma de generar los mipmaps de forma automática es usar

funciones incluidas en la librería GLU. Estas funciones cargan la

imagen base y todos los niveles de mipmap:

gluBuild1DMipmaps(target, internalFormat,

width, format, type, data);


width, height, format, type, data);


width, height, depth format, type, data);

60



4.6 Mipmaps

• A partir de la versión 1.4, OpenGL permite generar automáticamente

los mipmaps utilizando aceleración hardware. Para ello hay que

activar el parámetro GL_GENERATE_MIPMAP.

glTexParameteri(GL_TEXTURE_2D,

GL_GENERATE_MIPMAP, GL_TRUE);

• Desde la versión 3.0, OpenGL permite generar automáticamente los

mipmaps utilizando la función

glGenerateMipmap(GLenum target);

61



4.6 Mipmaps

• OpenGL calcula internamente cual es el mejor nivel de mipmap a

aplicar. Este criterio de selección se puede modificar configurando un

sesgo en el entorno de textura:

glTexEnvf(GL_TEXTURE_FILTER_CONTROL,

GL_TEXTURE_LOD_BIAS, -1.5);

62



Índice

4.1 Bitmaps

4.2 Pixmaps




4.6 Mipmaps



63




• A partir de la versión 1.3, OpenGL permite almacenar las texturas en

formatos comprimidos. Los valores de internalFormat que indican

formatos comprimidos son

• Si al cargar una textura se indica que el formato interno es

comprimido, OpenGL realiza automáticamente la compresión de los

datos.

• Se puede indicar el tipo de método de compresión a utilizar

glHint(GL_TEXTURE_COMPRESSION_HINT, GL_FASTEST);

glHint(GL_TEXTURE_COMPRESSION_HINT, GL_NICEST);

glHint(GL_TEXTURE_COMPRESSION_HINT, GL_DONT_CARE);

64

GL_COMPRESSED_RGB GL_COMPRESSED_RGBA

GL_COMPRESSED_SRGB GL_COMPRESSED_SRGB_ALPHA

GL_COMPRESSED_RED GL_COMPRESSED_RG




• Se puede obtener la versión comprimida de la imagen almacenada

con la función

glGetCompressedTexImage(GLenum target,

GLint lod,

GLvoid * img);

• donde target corresponde a la textura que se pretende leer, lod es el

nivel de mipmap e img el puntero a los datos.

• Estos datos se pueden almacenar externamente y cargarlos

directamente. En ocasiones esta carga puede crear problemas si el

fabricante de la tarjeta gráfica utiliza una versión no estándar del

algoritmo de compresión.

65




• Para cargar directamente los datos ya comprimidos se utilizan las

funciones

glCompressedTexImage1D(GLenum target, GLint level,

GLenum internalFormat,

GLsizei width,

GLint border, GLsizei imageSize, void *data);



GLsizei width, GLsizei height,

GLint border, GLsizei imageSize, void *data);



GLsizei width, GLsizei height, GLsizei depth,

GLint border, GLsizei imageSize, void *data); 66



Índice

4.1 Bitmaps

4.2 Pixmaps




4.6 Mipmaps



67




• Asignar las coordenadas de textura a los vértices supone una

operación de modelado bastante compleja. Generalmente se utilizan

herramientas de modelado para generar estas coordenadas de una

forma más cómoda.

• OpenGL incluye funciones que permiten generar las coordenadas de

textura de forma automática. Para utilizarlas es necesario activar

esta opción para cada una de las componentes:

glEnable(GL_TEXTURE_GEN_S);

glEnable(GL_TEXTURE_GEN_T);

glEnable(GL_TEXTURE_GEN_R);

glEnable(GL_TEXTURE_GEN_Q);

68




• Una vez activada esta opción, las llamadas a glTexCoord..() son

ignoradas.

• Se puede desactivar la opción con las correspondientes llamadas a

glDisable().

• Para configurar el método de generación de coordenadas se utiliza

la función glTexGen..().

glTexGeni(GLenum coord, GLenum pname, GLint param);

glTexGenf(GLenum coord, GLenum pname, GLfloat param);

glTexGenfv(GLenum coord, GLenum pname, GLfloat * params);

69




• coord se refiere a la coordenada de textura a configurar: GL_S, GL_T,

GL_R, GL_Q.

• pname se refiere al parámetro a configurar. Puede ser

GL_TEXTURE_GEN_MODE, GL_OBJECT_PLANE o

GL_EYE_PLANE.

• param contiene el valor asignado al parámetro a configurar.

• El método de generación de las coordenadas se configura con el

parámetro GL_TEXTURE_GEN_MODE, que puede contener los

valores

70

GL_OBJECT_LINEAR GL_EYE_LINEAR

GL_SPHERE_MAP GL_NORMAL_MAP

GL_REFLECTION_MAP




• El método GL_OBJECT_LINEAR calcula la coordenada mediante la

función

g = p1 · x + p2 · y + p3 · z + p4 · w

• Donde (x,y,z,w) son las coordenadas del vértice (antes de ser

multiplicadas por la matriz modelview) y (p1,p2,p3,p4) son las

coordenadas de un plano (asignadas mediante el parámetro

GL_OBJECT_PLANE). La ecuación supone asignar a la coordenada

un valor proporcional a la distancia del vértice al plano.

71




• El método GL_EYE_LINEAR calcula la coordenada mediante la

función

g = p1’ · x + p2’ · y + p3’ · z + p4’ · w

(p1’, p2’, p3’, p4’) = (p1, p2, p3, p4) · M-1

• Donde (x,y,z,w) son las coordenadas del vértice en el sistema de

referencia del observador (es decir, después de ser multiplicadas por

la matriz modelview), M es el contenido de la matriz modelview en

el punto de llamada a glTexGen y (p1,p2,p3,p4) son las coordenadas

de un plano (asignadas mediante el parámetro GL_EYE_PLANE).

• La ecuación supone asignar a la coordenada un valor proporcional a

la distancia del vértice al plano descrito en coordenadas del

observador.

72




• El método GL_SPHERE_MAP utiliza las coordenadas del vértice y

las normales para calcular una especie de proyección esférica del

modelo.

• Los métodos GL_NORMAL_MAP y GL_REFLECTION_MAP se

utilizan con un modelo de textura denominado CubeMap.

73




• El modelo cube map consiste en utilizar 6 texturas formando un

cubo. De esta forma las texturas describen un volumen en lugar de

un plano.

• Para cargar las texturas se utilizan como parámetro target los valores

• Para utilizar este modelo de textura hay que activarlo

glEnable(GL_TEXTURE_CUBE_MAP);

74

GL_TEXTURE_CUBE_MAP_POSITIVE_X GL_TEXTURE_CUBE_MAP_NEGATIVE_X

GL_TEXTURE_CUBE_MAP_POSITIVE_Y GL_TEXTURE_CUBE_MAP_NEGATIVE_Y

GL_TEXTURE_CUBE_MAP_POSITIVE_Z GL_TEXTURE_CUBE_MAP_NEGATIVE_Z




• En este modelo de textura, las coordenadas se indican con tres

valores (x,y,z) donde alguno de ellos debe ser +1 o -1 indicando la

cara del cubo en el que se encuentra la coordenada.

• Los modelos GL_NORMAL_MAP y GL_REFLECTION_MAP

generan automáticamente las coordenadas de textura como la

proyección del cubo sobre el objeto.

• Este modelo se utiliza habitualmente para generar superficies que

reflejan el entorno.

75

Tema 4 Imágenes y texturas - UHUuhu.es/francisco.moreno/gii_vg/docs/Tema_4.pdf · 2015. 10. 1. ·...

Documents

Transcript of Tema 4 Imágenes y texturas - UHUuhu.es/francisco.moreno/gii_vg/docs/Tema_4.pdf · 2015. 10. 1. ·...