La imagen de profundidad (Depth Images)

Como se ha comentado anteriormente, la imagen de profundidad de Kinect permite saber a que distancia están los objetos de ella a través del color de los pixeles.

Processing con esta librería puede acceder a la imagen de profundidad de kinect y mostrarla en pantalla, analizar los pixeles para hacer mediciones del espacio enfrente de ella y usar estos resultados como un interface de usuario normal, esta vez situado en el espacio real, no en el virtual.

Acceder a cada pixel:

Si se hace clic en puntos de la imagen se ve,  a través de la función color que nos devuelve números rgb de 0 a 255,  que en una escala de grises de la imagen de profundidad, no son mas que valores de brillo, lo cual significa realmente “distancia entre blanco y negro”-

 void mousePressed(){
Color c=get(mosueYX,mouseX);
println (red(c));
println (green(c));
println (blue(c));
}

Estos valores de  brillo de depthImage desde 0 a 255 los podríamos “mappear” a distancias que va de 0 a 8000 milímetros del mundo real,

Pero mejor aun, SimpleOpenNI nos da una función que devuelve la distancia de profundidad a mas resolución, de 0 a 2047, con una resolución de 11 bits por pixel:

kinect.depthMap();

A partir de esta función, para acceder a cada pixel y con él a las medidas de profundidad que representan, se llama a la función anterior, y guardamos los valores en un array de valores enteros en cual está formado de la siguiente manera.

int[] profundidad = kinect.depthMap();

Acceso al array de pixeles:

Para alcanzar lo valores de alta resolución de la imagen, que depthMap recoge, los cuales no puede guardar con pixeles de imagen, se guardan como enteros(int) en un array.

Para poder guardar en un array de números lo mismo que un pixel de una imagen son necesarios  unos cálculos para acceder a cualquier ubicación en la imagen, y la relación entre la imagen y el array.

Partimos la imagen en pixeles y se introduce en un array que contiene pixeles, pixel a pixel:

1 2 3 4 5 6 7 8
 9 10 11 12 13 14 15 16
17 18 19 20 21 22 23 24
25 26 27 28 29 30 31 32
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Se empieza con el pixel de arriba-izquierda de la imagen. Se pone en la caja, nos movemos hacia la derecha alrededor de toda la fila de pixeles de arriba. Ponemos cada pixel en una posición de la caja. Cuando acabemos la fila bajamos a la siguiente y así se repite continuamente hasta que se alcance el final, el último pixel de la derecha.

Se obtiene así un array con todos los datos por filas, uno detrás de otro.

Esto es exactamente lo que devuelve dephtMap. Al ser una imagen de 640 x 480 pixeles, el array contiene 307,200 enteros.

Se sabe entonces que cada primer pixel de cada fila será un múltiplo de 640, por lo tanto, para obtener un pixel de la fila por ejemplo 12., se sabe que la posición del array de este pixel tiene que ser mayor que el pixel primero de esa fila, por lo que sabemos que es la “posición y”  es 12 * 640 que es el ancho de cada fila. (recorremos 12 filas antes) y luego le sumamos la “posición x” que es la que buscamos.

Por lo tanto la posición  concreta de un pixel de la imagen en el array de enteros se calcula:

 x+y * ancho

Esto se hacer recorriendo con un doble for las posiciones x e y de la imagen.

Al hacer el recorrido en x e y en el array, vamos pixel a pixel recorriendo la imagen, Y cada valor de posición en el array es la posición en la que estamos ahora mismo en el recorrido.

int[] profundidad = kinect.depthMap();//recojo el array de profundidad
for (int x=0; x<w; x+=skip) {// ver cada pixel de la fila
for (int y=0; y<h; y+=skip) {// Por cada fila en la imagen de profundidad
int posicion_en_array = x+y*w; //Por cada pixel recoger la posición del arrya 
int profundidad_pixel_actual = profundidad[posicion_en_array];//recoger el correspondiente valor de la array
 

Profundidad:

El pixel que devuelve almacenado en esa posición, para poder procesarlo en Processing, va desde 450 para las partes mas brillante de la imagen (mas cercanas) y 8000 para las mas oscuras (lejanas). En efecto cada valor devuelto es la distancia en mm del objeto que detecta Kinect. Cuando no está en el rango de visión de Kinect, esta devuelve 0.

Etiquetas: , ,

About Miriam Esteve

Ingeniera & creativa. Amiga de mis amigos. Me gustan las cosas bonitas, el diseño, el video y la fotografía, cocinar, reír y disfrutar de la vida! Spain&Germany www.control-art.com

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: