Realidad Virtual: Dispositivos hápticos, OpenGL, Wii

Nov 25

Realidad Virtual: Dispositivos hápticos, OpenGL, Wii

Los últimos controladores para videojuegos sin cables son el mando de la Wii, el Kinnect de XBox y el micrófono de PS3, pero existen otros dispositivos llamados hápticos (comportamiento del contacto y las sensaciones) que no son para consolas, aunque un poco más caros pero que permiten hacer aplicaciones como simuladores de operación o videojuegos, algunos de estos dispositivos sí que necesitan cables, sin embargo la ventaja es la de poder operar telemáticamente, i.e., realizar cambios de forma local en un ordenador y replicar dichos cambios a distancia, veamos algunos ejemplos:

  • Sensable: vídeos de aplicaciones para hápticos.
  • Concretamente aquí tenéis código fuente para jugar con uno de sus dispositivos: el Phantom, como cuesta bastante dinero tenéis que pedir permiso en una Universidad para que os lo presten o bien podéis utilizar un emulador, aún no he encontrado éste último pero si que he probado el dispositivo real en la Universidad Rey Juan Carlos, en el Campus de Móstoles.
  • Hapty MASTER: único dispositivo de admitancia

Recordar algunos términos:

  • roll: aleteo
  • yaw: guiñada
  • pitch: cabeceo
  • principal component analysis: se tienen en cuenta sólo vibraciones q desprenden mayor energía, el resto se obvian
  • sistema jerárquico de puntos-> detección de colisiones con puntos de control precalculados

Estos términos tienen que ver con las operaciones que se hacen en la pantalla con los objetos, las cámaras, etc., HIP es una matriz de transformación fija.

Cómo se hace la detección de colisiones en un programa en OpenGL para un dispositivo háptico como un Omni Phantom de Sensable? pues simplemente, se tienen dos bucles de dibujado, uno para el render de pantalla y otro para el render interno del dispositivo, de modo que éste solo “ve” lo que se pinte en su parte. De esta forma podemos utilizar los eventos dispuestos a tal efecto e interactuar con el puntero, los botones, etc y los objetos en pantalla.

Ahora estamos en condiciones de hacer las prácticas:

En el caso de la interacción con el mando de la Wii (Wiimote) la práctica consiste en programar un tracking de una cámara usando los sensores de aquel, de forma que dicha cámara apunte donde apunta el mando.

¿Cómo hacer una aplicación con estereoscopía?

Lo que hoy se vende como 3D con las TV, los nuevos juegos de la PS3,etc., en realidad se llama estereoscopía, es decir, simular una imagen 3D duplicando la imagen normal en pantalla pero girando el ángulo de la cámara del ojo derecho y aplicando una separación y otros cálculos, en nuestro caso, para hacer juegos con estereoscopía (para gafas 3D de rojo y verde) lo que vamos a utilizar es la librería COIN 3D o el Open GL de Python. En el primer caso sólo necesitáis el material siguiente:

Vamos a hacer un repaso de lo que es una cámara estéreo con los valores que he encontrado en internet ( http://www.binocularity.org/page24.php ):
he escrito el siguiente pseudocódigo con eso

funcion calculoPerspectiva(){
w = 518.4 # dimensiones físicas de ancho de la pantalla en     milímetros
h = 324.0 # (alto)

Z = 1000.0 # Distancia en la escena desde la cámara al plano     de la pantalla
A = 65.0   # separación entre cámaras, es decir la     separación entre los ojos
Near = 800.0  # distancia en la escena desde la cámara al     plano near
Far = 1200.0 # distancia en la escena desde la cámera al     plano far

half_fov = math.atan( (h/2.0) / Z )
fov = math.degrees( 2.0 * half_fov ) # campo de visión     -field of view (fov)- en dirección de y (eje vertical).

//  INSTRUCCIONES PARA CADA OJO (CAMARA):
lookAtIZDA = (
-A/2, 0, 0, 0, 0, -Z, 0, 1, 0 )
lookAtDCHA = (
A/2, 0, 0, 0, 0, -Z, 0, 1, 0 )
//   INSTRUCCIONES PARA PERSPECTIVA
Perspectiva = ( fov, w/h, Near, Far ) # Parametros para la     instrucción de OpenGL gluPerspective--> a traducir en COIN...
return Perspectiva,lookAtIZDA, lookAtDCHA;
}

ahora, con esta función lo que tenemos que hacer es renderizar cada camara, izda y derecha:

funcion dibujar_lo_que_ve_la_pantalla(ojo){
glViewport( 0, 0,  ANCHO_VENTANA , ALTO_VENTANA)
[lookAtIZDA, lookAtDCHA , Perspectiva ] := calculoPerspectiva();
g = Perspectiva
if (ojo == "izquierdo") {
// renderizar Perspectiva y lookAt a los puntos de la     izquierda
l = lookAtIZDA
} else {
l = lookAtDCHA
}
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective( g[0], g[1], g[2], g[3] ) // --> ver <a href="http://profs.sci.univr.it/%7Ecolombar/html_openGL_tutorial/en/03basic_transforms_018.html" target="_blank">http://profs.sci.univr.it/~colombar/html_openGL_tutorial/en/03basic_transforms_018.html</a>
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
gluLookAt( l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7], l[8]     )
}

y con eso funciona, al menos en python y Open GL, a mi me ha funcionado el python pero no tengo gafas rojas y verdes y no he podido fusionar como goku y vegeta.
Te puedes bajar Python para windows de aquí:
http://www.python.org/download/
y pyOpenGL de aquí:
http://pypi.python.org/pypi/PyOpenGL
El paquete que te adjunto lo descomprimes y desde la consola pones “python.exe toedIn.py ANAGLYPH” y verás los cubos en 3D como la captura que mando.

Si tenéis cualquier duda os la soluciono rápido 🙂

Artículos relacionados

Exprésate dejando un comentario:

Introduce el captcha

Por favor escriba los caracteres de la imagen captcha en el cuadro de entrada