lunes, 12 de julio de 2010

Line Integral Convolution

Admito que últimamente nada más que posteo de los trabajos que hago en el máster, pero es que da una alegría cuando te sale algo después de tirarte un par de semanas depurando ...

Os acordáis de lo que os conté del programa que estaba haciendo para tratar las imágenes y que parecieran dibujos, sino pues aquí os dejo un enlace :P. El caso es que uno de los pasos previos era calcular la matriz ETF (Edge Tangent Flow) que básicamente es una matriz de vectores que indican la dirección en la que van los colores.

En los artículos que teníamos de referencia para implementar esto, siempre salían las imágenes que representaban el ETF en forma de imagen, y que la verdad vienen bastante bien para saber si estás calculando bien el ETF o no. Así que después de pensarlo me decidí a implementarlo, pero la cosa no era nada fácil ... El artículo en el que venía explicado el LIC, la notación matemática que usaba era chino total, no entendía nada de nada. Pero seguí buscando hasta que encontré un algoritmo que según el nombre era más rápido que el LIC tradicional, el Fast LIC.

Después de leerlo vi que todo era mucho más sencillo :P. Y la verdad nos ayudó mucho con la parte de extracción de líneas y de color :).

Os voy a dejar el pseudocódigo del algoritmo, que su trabajo me ha costado depurar.

for (i = 0; i <> for (j = 0; j <> if (numHits(i, j) <> calculo el streamline con centro en el punto (i, j); calculo Ix0; actualizo I(i, j); for (m = 1; m <> calculo Ixm; actualizo I(streamline(m)); calculo Ix-m; actualizo I(streamline(m)); } } } }

Como se calcula el streamline, por cierto el streamline es una línea que sigue el flujo de la matriz ETF de tamaño 2*(M+L-1).

Calcular Streamline:

siguiente = anterior = origen; for (i = 0; i <> siguiente = punto siguiente (ht, ETF, siguiente); añadir siguiente a la lista de puntos siguientes; anterior = punto siguiente (-ht, ETF, anterior); añadir anterior a la lista de puntos anteriores; }
punto siguiente(h, ETF, punto):

v = ETF(punto); k1 = v * h; v = ETF(punto + k1 * 0.5); k2 = v * h; v = ETF(punto + k2 * 0.5); k3 = v * h; v = ETF(punto + k3); k4 = v * h; resultado = punto + k1/6 + k2/3 + k3/3 + k4/6;

Calcular Ix0:

Ix0 = 0; for (l = -L; l <= L; l++){ if (valido(stl(l))){ Ix0 += textura(stl(l)); validos ++; } } Ix0 = Ix0 / validos;

Calcular Ixm:

k = 1 / validos; Ixm = Ixm + k * (textura(stl(m+L)) - textura(stl(m-L-1)));

Calcular Ix-m:

k = 1 / validos; Ix-m = Ix-m + k * (textura(stl(m-L)) - textura(stl(m+L+1)));

Y estas son algunas imágenes de su funcionamiento :). Si queréis verlas mejor, os aconsejo que pinchéis sobre ellas y las podáis ver más grandes :P












sábado, 3 de julio de 2010

Magic Potter

El título del post puede sonar a que podría ser algo de Harry Potter aunque en realidad no lo es :P. Magic Potter es el nombre del programa que hice para el proyecto fin de carrera :). Se llama así porque de lo que va el programa es de la reconstrucción de vasijas, y potter en inglés significa alfarero :P.

Os preguntareis si hace ya 4 años que acabó la carrera a que viene esto. Pues básicamente porque estaba recordando que tenía algunos vídeos en google vídeos y lo he visto, y me ha parecido bien ponerlo aquí y que la gente lo vea. También porque el proyecto fin de máster que quiero hacer tiene bastante que ver con mi proyecto fin de carrera, y espero que tengo el mismo o más éxito que el proyecto y me de para escribir más de un articulillo :P.

El proyecto lo programé en Java usando el api de Java3D, y yo diría que dudo mucho que vuelva a programar algo más en Java3D, más que na porque tuve que reimplementarme todos los eventos del ratón y del teclado porque no se podía hacer nada con ellos ... Supongo que en algún momento cogeré de nuevo el proyecto y lo haré un poco más profesional :P. Pero por ahora lo que hay es lo que se ve en el vídeo :P





Bump Mapping mejorado

Llevo sin actualizar bastante el blog, y la verdad no es que haya estado sin hacer nada precisamente, los que me siguen por twitter saben que ultimamente mi vida se resume en ir al trabajo, programar por las tardes los trabajos que me quedan del máster y para desconectar ir a karate...

Ahora vuelvo con algo de lo que ya había escrito, pero por varios motivos, entre ellos que uno de los profesores me ha pedido que le añadiese un par de cosas al algoritmo, y también por ver que es lo que le faltaba, he vuelto a tocar el código del bump mapping.

Las mejoras principales, es que he corregido las erratas en el código motivadas muchas por el copy & paste y otras por despiste de signos y operaciones ... Ya funciona correctamente sin hacer cosas raras ni nada :D, la textura se mapea bien y no aparecen regiones vacías ... Esta es una de las mejoras más importantes, la otra es que la esfera se puede rotar, se puede cambiar la posición de la luz, incluso acercarla o alejarla y acercarnos a la esfera para ver el detalle.

El nuevo código lo podéis descargar aquí (el fichero es bump_mapping2.tar.gz)

Y para los que no tengan ganas de compilarlo o simplemente no tengan instalado linux, os dejo un vídeo que he hecho :). Os aconsejo, para ver mejor el detalle, que lo veáis directamente en youtube y en pantalla completa :P