-[ 0x0C ]--------------------------------------------------------------------
-[ HDM ]---------------------------------------------------------------------
-[ by FCA00000 ]-----------------------------------------------------SET-32--


En este artculo voy a contar los desvaros de un amiguete mo llamado Antonio.
Yo soy simplemente el escritor de algunas partes de este artculo, y aunque le 
ayud un poco, todo el mrito es suyo. Le cost bastante esfuerzo hacer este 
proyecto, y yo fu espectador de ese trabajo.
Creo que se merece un poco de publicidad y sus 15 minutos de fama. Este es mi 
homenaje a su labor.

Est contado como si hubiramos hecho este proyecto juntos, pero no es cierto. 
Me ha obligado l a escribirlo as.

He hubiera gustado incluir fotografas, pero el sistema est tan chapucero que 
da un poco de vergenza. Adems el formato de SET no permite dibujos.

El chico ha hecho muchos programas de ordenador, y le gustan los grficos en 3D.
Es por eso que hace tiempo se compro en eBay de segunda mano unas gafas que 
contienen una pequea pantalla en caja ojo.
Esto permite que la imagen sea distinta para cada ojo, lo que proporciona 
imagenes estereoscpicas, con sensacin de profundidad.
Tras probar unos cuantos juegos y ver que efectivamente se consigue una 
impresin de inmersin en un mundo 3D, decidi que l tambin quera hacer algo
parecido.
Muchos de los programadores que hacen grficos para ordenadores conocen los 
algoritmos y trucos para convertir un escenario en 3D en algo que se pueda ver 
la pantalla del ordenador. Yo simplemente los voy a describir.
Lo primero es tener el escenario -tambin conocido como "mundo"- organizado por
distancias. Los objetos ms cercanos se dibujarn con todo detalle, y los ms 
lejanos se dibujan como simples bloques.

Esta distancia es relativa al punto de vista, es decir, dnde est situado el 
observador. En el caso de imagenes estereoscpicas, hay 2 puntos de visin, uno
por cada ojo. Esto implica que hay que dibujar la imagen dos veces.
El tercer elemento es el plano de interseccin. Para dibujar los objetos 
primero se imagina una ventana, y se traza una lnea desde el punto de visin 
hasta el objeto ms cercano. El punto donde se interceptan dicha lnea y la 
ventana, es el que se dibujar en pantalla.
En realidad slo se calculan los vrtices de los polgonos, y las superficies 
de los objetos se dividen en tringulos, que son los elementos ms simples que 
se pueden dibujar. Existen mltiples mtodos de triangulacin, eligiendo un 
punto interior a la superficie, y trazando lneas hasta los vrtices.
Luego se rellena cada tringulo.

Estos clculos se realizan con funciones trigonomtricas, que frecuentemente se
realizan en un procesador dedicado, o bien la propia tarjeta grfica es capaz 
de hacerlo, incluyendo texturas y dibujado optimizado de tringulos.
Existe muchsima documentacin al respecto, as que no comentar ms.

Las gafas estereoscpicas normalmente obtienen la seal de video desde la 
tarjeta grfica.
Podra pensarse que se conectan a la salida de monitor, pero esto obligara a 
que la seal digital generada por el procesador se conviertiera a analgica 
para el monitor, y luego las gafas las deberan convertir a digital de nuevo. 
Esto es una prdida de tiempo que es mejor evitar.
Por eso lo mas normal es que se conecten a la salida digital de la tarjeta 
grfica, o, si no la hay, al llamado "bus de servicio" de la tarjeta, que es un
conector extra. En mi caso tiene 28 pins.

La resolucin de las gafas (baratas) es muy inferior a VGA. Los modelos 
i-Glasses y VFX1 tienen 180.000 pixels para caja ojo.
Pero la manera de medirlos tiene truco: cada pixel slo puede representar un 
color (rojo, verde, o azul), en una gama de 256 niveles. Por eso para dibujar 
1 pixel a color real (16.000.000 de colores) hacen falta 3 pixels en las gafas.
Esto hace que en realidad solo haya 180.000/3 = 60.000 pixels a color total. 
Esto da una resolucin de 260x230, inferior incluso al antiguo estndar MCGA 
(320x200)
Vamos a hacer un clculo simple: 260 pixels permiten mostrar 30 lneas de texto
con un tipo de letra de 8 pixels de alto.
Esta resolucin es slo ligeramente superior a la de un ZX-Spectrum, y peor que
una PSP.

Para que la imagen de ambos ojos sea distinta, hay que dibujar en la pantalla 2
imgenes entrelazadas: una en las lneas impares que se ver en el ojo 
izquierdo, y otra en las lneas pares que se ver en el ojo derecho.
Hay otro modo usado por otras gafas, y es alternar la imagen cada 1/60 de 
segundo, pero eso es ms complicado de programar.

Ahora es cuando explico el objetivo: intentamos que en las gafas se represente 
el escritorio del ordenador, en un sistema como MS-Windows o Linux-KDE
Los objetos (iconos, ventanas, cursor, ...) se presentarn en distintos planos,
con aspecto 3D. Ser posible mover los objetos y tambin el punto de visin, 
para verlos desde otra istancia y desde otro ngulo.
Ya de antemano se entiende que con esta resolucin tan ridcula va a ser 
imposible conseguir mucho, pero la aventura es la aventura.
Imagnate el escritorio en tu pantalla de 15 pulgadas, por ejemplo a 1024x768.
Ahora qudate slo con 1/4 de la pantalla, tanto a lo ancho como a lo alto. Eso
es lo que se puede ver con las gafas.
Haz la prueba: en una hoja de papel haz un hueco de 8x6 cm, y ponlo sobre la 
pantalla, Ahora intenta usar tu ordenador viendo a travs de este hueco.

A cambio tiene una cosa buena: mires donde mires, la pantalla siempre estar 
delante de tus ojos.

Un sistema HMD-Head Mounted Display se compone de un visor, y algn mecanismo 
de posicionamiento del usuario. Comunmente es un girscopo o un medidor 
magntico que se lleva sobre la cabeza.
Cuando giras la cabeza, el sistema sabe que pretendes mirar a otro sitio, y 
puede mostrar una imagen diferente, dando la impresin de que ests inmerso en 
un mundo completo, generado por el ordenador.
Si te mueves, el sistema sabe que te has desplazado y presenta la imagen tal 
como se ve desde el nuevo punto de visin.
Estos sistemas pueden ser incluso ms caros que las propias gafas. Sobre todo 
porque no hay mucha gente que los compre. La publicidad de los comerciantes 
muestran a ingenieros diseando coches y edificios, mdicos operando a 
distancia, qumicos alterando las molculas, y militares desplegando sus tropas.
Debo decir que el nico sistema comercial que he visto yo ha sido en una sala 
de videojuegos y en una representacin de arte "virtual".

Pero mi amigo pretende suplir la falta de resolucin con la disponibilidad de 
espacio. Slo puede ver 260x230 en cada ojo, pero dispone de 4 paredes de 3 x 2
metros. Ahora lo explicar en detalle.
Las gafas tienen un FOV-Field Of View de 45 grados. Esto quiere decir que a una
distancia de 2 metros representa una ventana de 1.5 x 1 metros.
As, una pared de 3 metros de ancho es capaz de contener 2 pantallas de 1.5 
metros, lo que equivale a 2*260 pixels.
En otras palabras: sentado en el centro de su habitacin, el escritorio de 1024
pixels de ancho le cabe en 2 paredes contiguas, lo que implica girar la cabeza 
90 grados en cada sentido:
Cada pixel parece que mide 6 milimetros.

<--256 pixels--><--256 pixels-->
<-----------512 pixels--------->
<--------------3 metros ------->
<-- 1 pantalla-><-- 1 pantalla->
^
|
|
|
|
2 metros
|
|
|
v


Como he dicho, las lneas pares de la pantalla se dibujan en un ojo, y las 
impares en el otro. Por supuesto que esto hace que no se vea bien en la 
pantalla del ordenador, pero en las gafas queda realmente con efecto 3D.
La primera prueba que hicimos fue muy graciosa: pintamos las lneas pares de 
color amarillo, y las impares de azul. El resultado es que el usuario ve la 
pantalla de color verde, como caba esperar.
Lo siguiente fue dibujar un objeto con propiedades 3D, y el ms sencillo es un 
cubo. No, no un cubo de fregar el suelo, sino un hexaedro. Haz el siguiente 
experimento: toma un cubo de 20x20 centmetros, por ejemplo una caja de cartn.
Guia un ojo y coloca el cubo a unos 20 cm. de manera que una de las aristas 
apunte directamente al ojo abierto. Obviamente ves un cuadrado, pues el cerebro
no entiende que hay una parte posterior.
Esa es la imagen que dibujamos en las lneas pares.
Guia el otro ojo, y ahora ves que el objeto tiene profundidad. Eso es lo que 
dibujamos para el otro ojo. Al verlo con las gafas, daba un cierto aspecto de 
3D. Tras aadir texturas, sombras, y un poco de antialiasing, el cubo ya tena 
mejor aspecto.
Ampliamos el programa para girar y desplazar el cubo en el espacio, y el efecto
era sorprendente.
Jugamos un rato variando la distancia entre los dos puntos de vista IPD 
Inter-Pupillary Distance. La mayora de las personas tienen entre 6 y 8 
centmetros. Establecer 2 puntos de vista separados ms de 9 centmetros hace 
que los objetos parezcan curvados. Ms de 11 centmetros y el cerebro no 
entiende la imagen, que pasa a ser uni-focal. Es como si uno de los ojos se 
desconectara.
Aunque estos experimentos sin duda son graciosos e interesantes, nuestro 
objetivo es hacer un escritorio virtual, no estudios sobre la visin.
Todas las pruebas anteriores las hicimos con OpenGL, dentro de una ventana 
dedicada. Ahora toca convertir el escritorio en 3D.

El primer intento lo hicimos sobre Linux. El sistema estndar de ventanas es 
X-Window. Esto usa un modelo en el que el display acta como servidor de 
grficos, y las aplicaciones son los clientes.
En X11R5 y XF86 se pueden definir varias resoluciones. Lo mnimo es VGA 640x480
pero existen drivers para resoluciones menores tales como Hrcules, o 8510, que
slo recordarn los ms viejos del lugar. Lamentablemente no estn soportados a
partir de la versin 4.0 , y los de la 3.4 son demasiado distintos como para 
poder adaptarlos.

Nosotros queramos que la resolucin fuera parecida a la que tienen las gafas. 
Si no, apareceran problemas. Por ejemplo, sera posible mover el ratn a la 
posicin (400,400) y seguira apareciendo en el monitor, pero no en las gafas.

Una posible solucin sera establecer un area virtual. En X-window se puede 
definir el tamao a partir del cual la pantalla tiene que hacer scroll. Esto 
impide que el ratn vaya ms all. Lamentablemente el rea virtual debe ser 
ms grande que el rea real, y no viceversa. Para los que se hayan perdido: si 
el monitor slo puede representar 640x480 entonces puedes definir un rea 
virtual de 1024x768, y la pantalla se desplazar automticamente cuando muevas 
el raton ms all del lmite. Por supuesto no puedes ver toda la pantalla a la 
vez, pero s a cachitos.
As que tuvimos que ver dnde y cmo se haca el scroll. No fue difcil 
adaptarlo para que lo hiciera cuando llegara ms all de 260x230.

Ahora lo malo es el tamao. Los iconos ms pequeos de KDE ocupan 48x48. Pones 
4x4 iconos en pantalla, y ya la tenemos llena.
Y el cursor del ratn ocupa 16x16, es decir, 1/15 de pantalla. Haz la prueba de
definir un cursor de 1.5 cm. para tu pantalla de 15 pulgadas, y ya vers lo 
grande que queda.
Por ltimo quedaba la decoracin de las ventanas. Los bordes, mrgenes, barra 
de ttulo, ... ocupan demasiado y se comen casi todo el rea de visualizacin.
Podamos cambiar el driver para que dibujara slo los pixels verticales pares, 
es decir, comprimir la pantalla a lo ancho en un 50%. Fue sencillo de 
programar, pero qued realmente feo.
La segunda solucin podra ser cambiar todos estos elementos, y hacerlos ms 
adecuados a nuestro espacio de visin. ?Quin necesita un cursor de 16x16, que 
en las gafas parece ocupar 10 centmetros?
La otra solucin era usar un escritorio ms sencillo, como fvwm2. Entonces 
tendramos que cambiar los iconos, o al menos la manera de dibujarlos para que 
aparezcan en 3D.

Por supuesto siempre podramos adquirir otras gafas, como mayor resolucin. No 
slo ganaramos ms rea de dibujado, sino que ms pixeles daran mayor 
nitidez. Ya no veramos esos puntos tan gordos en la pantalla virtual.
Pero eso tiene un coste. Y las gafas HMD no son un producto especialmente 
popular, por lo que no hay muchos fabricantes, y los precios no bajan con la 
misma velocidad que la de los lectores MP3.
Para una resolucin de 640x480 hay que soltar al menos 1.000 euros, y nosotros 
no estamos dispuestos a gastarnos todo eso en algo que slo queremos para 
jugar.
Sin embargo tomamos otra decisin, fruto sin duda de la desesperacin y el 
tequila: haramos nuestras propias gafas.

Obviamente deban ser porttiles. La solucin de poner en un arns 2 monitores 
a la altura de los ojos no era viable.
Tampoco vala un sistema de espejos que estuvieran conectados a los monitores.
La posibilidad de usar un proyector de diapositivas para proyectar la imagen en
la pared tampoco vala, pues no es un entorno virtual en el que moviendo la 
cabeza veas una imagen distinta.
Colocar un GameBoy en cada ojo tampoco sirve, pues la resolucin es incluso 
menor.
As que terminamos usando una pantalla TFT que adquirimos en eBay por 50 euros.
Como pesaba 3 kilos, desenganchamos la pantalla de su marco y le quitamos todo 
el peso innecesario, dejando solamente el display y el cable que lo conecta a 
la circuitera de la placa del monitor. Una vez que bajamos el peso hasta 
500 gramos la fijamos a un casco de la construccin.
La pantalla queda en posicin horizontal a 10 cm de los ojos.

Este es el esquema, visto desde arriba: cada "O" es un ojo, y "^" es la nariz.

----------- <-pantalla
   O ^ O    <-ojos

El invento queda estrambtico, pero funciona.
En una segunda fase suspendimos la pantalla de un muelle del techo. Esto 
eliminaba mucho peso, pero impeda los movimientos por la habitacin.

Ahora la manera de dibujar es mostrar una imagen en la parte izquierda de la 
pantalla, y otra imagen en la seccin derecha.
A una resolucin de 1024x768, se usan 1024/2=512 pixels para cada ojo. Cada una
de estas partes las llamamos marco.
Como la pantalla est a unos 10 cm de los ojos, el FOV es 90 grados, es decir, 
que 512 pixels ocupan 10 cm. de visin. En otras palabras, es como si vieras 
una televisin de 2 metros de ancho a 1 metro de distancia, y cada pixel ocupa 
2 milimetros.

Pero otro asunto es hacer que el escritorio se muestre correctamente.

Para recapitular: queremos que cada elemento del escritorio (ventanas, iconos, 
puntero, barra de herramientas, ...) tenga una propiedad extra: profundidad. 
Para dibujarlos hay que tener en cuenta su posicin y su profundidad, y 
dibujarlo dependiendo si la imagen se ver en un marco o en el otro.

Si un icono del escritorio est en un plano muy lejano, la imagen debe estar 
en las mismas coordenadas en ambos marcos.
En cambio, si el icono est cercano, en el marco izquierdo debe tener una 
coordenada X de valor menor que la del marco derecho. Piensa un momento sobre 
esto: un objeto extremadamente cercano (2 cm.) al ojo izquierdo no se puede 
ver con el ojo derecho porque lo tapa la nariz, y porque no puedes bizquear 
tanto.
En X-window los objetos ya pueden incluir la propiedad de profundidad, pero en 
KDE lo nico que hay es el canal alfa, que se usa exclusivamente para 
transparencias.

Al parecer en el prximo MS-Windows ya se incluye este concepto de entorno en 
3D, lo que permite poner una aplicacin en primer plano de visin, mientras que
a travs de sus reas transparentes puedes seguir viendo las que estan detrs.
Lo mismo se aplica a Mac-X (o como se llame ahora), pero ambos entornos no son 
programables tanto como nosotros necesitamos.

Hacer que la misma imagen se muestre en ambos marcos fue fcil: le dijimos que 
tenamos una pantalla de 512x768, con lo que X-Window solo usaba la parte 
izquierda de la pantalla, es decir, el marco izquierdo. Luego parcheamos las 
rutinas de dibujo para que pintase exactamente lo mismo en las coordenadas
(x,y) que (x+512,y)

Eso s, tambin el cursor del ratn aparece 2 veces.

Ahora se trataba de darle profundidad a los objetos del escritorio. Usamos el 
gestor de ventanas fvwm2 porque es simple y rpido.
Cada objeto contiene una estructura para localizarlo en el escritorio. Esta 
estructura contiene las coordenaas X, Y, ademas de la anchura y la altura. 
Aadimos un dato ms para la profundidad.
Los dibujos de los objetos son siempre un mapa rectangular de bits plano. Para 
convertirlo en un objeto 3D hay que convertirlo en una caja (mas correctamente,
un ortoedro).
Esto se consigue ponindole un fondo y 4 caras.
As, un icono con dibujo de 16x24 lo convertimos en un objeto con 6 caras de 
profundidad 20, cada una con un dibujo.

                        +-----+
                       20    /|
   +-16--+            +-16--+ |
   |     |            |     | |
   24    |      --->  24    | |
   |     |            |     | +
   +-----+            +-----+/

La tarjeta de video es capaz de dibujar los lados del cubo sin ms que decirle 
cual es la textura correspondiente. Luego veremos que esto lamentablemente no 
se puede usar para al caso de visin estereoscpica.
Por supuesto el dibujo del fondo del cubo nunca es visible. Es ms, slo 3 
caras del cubo son visibles por un mismo ojo. Pero puede que el otro ojo vea 
otras caras del cubo. Haz la prueba: pon un dado de parchs a 3 cm de la punta 
de tu nariz . Con el ojo izquierdo vez la cara superior, la frontal, y la 
izquierda. Con el ojo derecho ves la cara superior, la frontal y la derecha. 
Este es el efecto que queremos conseguir.
Para slo un ojo ya lo hemos conseguido. Pero para conseguir vision 
estereoscpica hay que dibujar otra imagen en el marco derecho. Aqu entra la 
magia de X-window.
Como he comentado antes, X-window es una arquitectura en la que una aplicacin 
manda instrucciones para dibujar, y otra aplicacin (el servidor de grficos) 
se encarga de dibujarlos.
A quien hay que engaar es al cliente, no al servidor. Hay que hacer que el 
cliente calcule la imagen izquierda, la mande a dibujar, y luego calcule la 
imagen derecha desde un punto de visin diferente, y la mande a dibujar.
El cliente es en nuestro caso el gestor de escritorio fvwm2. En la rutina 
DrawObject se le pasa un puntero a un objeto grfico, normalmente porque ha 
cambiado su bitmap, o porque ha pasado a primer plano.
Esta rutina toma las coordenadas X, Y y el dibujo con el bitmap, y lo manda al 
servidor de grficos.
No resulta difcil modificarla para que considere las caras del ortoedro y 
mande un bitmap de tamao ligeramente ms grande.
Un poquillo de matemticas: si un ortoedro mide x,y,z , y se representa en 
perspectiva caballera, ?cul es el tamao mximo de su proyeccin sobre el eje 
Z ?
En otras palabras: ?cunto crece el bitmap con el objeto en 3D? La respuesta es
z/sqrt(2) , esto es ms o menos z/1.5
As, el objeto 3D anterior de 24x16x20 necesita un bitmap 2D de (24+20/1.5) x 
(16+20/1.5) = 38x30

Este dibujo necesita calcularse 2 veces, uno para cada marco. El resultado es 
ligeramente diferente para cada marco, excepto cuando el objeto no tiene 
profundidad, o sta es muy pequea respecto a la distancia. Esto sirve para 
agilizar el proceso de dibujo: los objetos que no han sido transformados a 
cubos (en una fase inicial empezamos slo con los iconos, olvidndonos de 
ventanas, puntero, ...) pueden usar el mismo dibujo en la misma posicin+512 
para ambos marcos.
Las rutinas tpicas de X-window usadas para inicializar el modo de dibujo son: 
XOpenWindow, XCreateGC, XMapWindow
Sin embargo fvwm2 tambin usa DisplayWidth, DisplayHeight que en nuestro caso 
debemos cambiar para que usen siempre 512, en vez de 1024.
En todos los sitios donde llama a xxx_Draw_xxx hay que llamarlo 2 veces, uno 
para cada marco.
Las primeras pruebas funcionaron bien: los iconos en 3D aparecan en ambos 
marcos.
Un poco ms difcil fue hacer que simularan tener distintas profundidades.
Aunque la tarjeta de video es capaz de dibujar objetos en 3D, no es capaz de 
considerar 2 puntos de visin.
Por ello tuvimos primero que proyectarlos a 2D, y dibujar los polgonos (la 
proyeccin de las caras son siempre rectngulos y romboides). La velocidad de 
dibujado no era un problema.
Una vez funcionando los iconos, las ventanas representaban una nueva 
dificultad: se podan solapar.
En 2D las ventanas son planas, por lo que el mayor problema sucede cuando una 
ventana est cubierta por varias, como en el dibujo:

 +--------+
 |        |
 |        |---------+
 |        |         | 
 |        |      +-------+
 +--------+      |       |
     |           +-------+
     |              |
     +--------------+

Pero en 3D un problem adicional sucede cuando una cara de una ventana solapa a 
otra:
       +---------+
      /         /|
     /         / |
    /         /  /+---+
   +---------+  /    /|
   |         | +----+ |
   |         | | B  | /
   |         | +----+/
   |    A    |   |
   |         |   +
   |         |  /
   |         | /
   +---------+/
Ms o menos se puede ver que el objeto B est ms atrs que A, pero sin embargo
lo solapa.
No se puede dibujar primero B y luego A porque no se vera medio B.
La solucin en este caso es pintar primero A y luego B. Pero esto es ilgico, 
puesto que A est delante de B.
Y si lo piensas un poco, sto vale para el ojo derecho. El izquierdo es posible
que ni siquera vea B, pues quizs A lo tapa.
Lo que hicimos es pintar primero la parte superior, luego la cara derecha, 
despues la inferior, la izquierda y finalmente la cara anterior. O sea, en el 
sentido de las agujas del reloj. Esto para el ojo derecho.
Para el ojo izquierdo el orden es: superior, izquierda, abajo, derecha, y 
anterior. O sea, en sentido contrario a las agujas del reloj.
Esto garantiza que las caras cubren lo que tienen que cubrir. Obviamente 
algunas zonas se pintan 2 veces, pero no ms, gracias a que tambin usamos la 
profundidad para dibujar primero los objetos ms lejanos.
La solucin ms exacta habra sido usar uno de los algoritmos de representacin
en 3D, pero para octoedros el algoritmo usado funciona perfectamente y es ms 
rpido.

Repito que no es posible pintar esferas ni objetos que no tengan 6 caras, pero 
para un escritorio sto es ms que suficiente.
Un paso ms all sera usar transparencias. Por ejemplo, los iconos siempre se 
inscriben en un rectngulo, pero comnmente tienen areas que son transparentes,
tomando formas no rectangulares, imagnate la letra T en 3D:
     _____________
    /            /|
   +------------+ |
   |            | /
   +----+   +---+/
        |   | |
        |   | |
        |   | |
        |   | |
        |   | /
        +---+/
En este caso no hay slo 4 lados, sino que cada lado se compone de varios 
rectngulos. Este caso no lo hemos implementado.

Ya podamos pintar iconos y ventanas. El siguiente paso era la decoracin de 
las ventanas: barra de ttulo, marco de ventana, barra de scroll, botn para 
minimizar y cerrar.
Estos elementos se llaman widgets. En X-window existen varios conjuntos de 
widgets. El inicial era Athena, bastante simple, formado por simples 
rectngulos de 1 nico color.
Luego surgieron Motif (y Lesstif), KDE, Gt, y otros muchos que no tuvieron 
tanta aceptacin y cayeron en el olvido.
En concreto fvwm2 usa unos widgets definidos especficamente. Tambin son 
bastante simples, en general un rectngulo con un marco, y una lnea superior 
y otra lateral para dar aspecto de tridimensionalidad.
Existen varios mdulos en http://fvwm-themes.sourceforge.net/ para hacer que 
parezcan como NeXT, Win95, Mac, ...

Por ejemplo el icono de cerrar una ventana es algo as:

    1234567890123456

1   *OOOOOOOOOOOOOO%
2   ...............@
3   ...X.......X...@
4   .....X...X.....@
5   .......X.......@
6   .....X...X.....@
7   ...X.......X...@
8   ...............@

que usa 5 colores, en una trama de 16x8 pixels
Este dibujo simula que el widget ocupa 15x7 y deja una linea horizontal 
superior y otra vertical a la derecha para simular la profundidad. Pero en 
realidad es 16x8 .
Este pixel extra que da sensacin de profundidad se llama Gravity y se calcula 
en geometry.c en la funcin gravity_get_offsets. El valor es 0, 1  -1.

Para nuestro caso lo cambiamos por un cubo en 3D de 16x8 con una profundidad de
1 pixel. Aunque luego lo cambiamos a 5 pixels de profundidad, para dar ms 
sensacin de 3D. El dibujo ocupa a lo ancho un total de 16 + 5/sqrt(2) = 16+4 =
20 cuando est a una distancia equivalente a 1 metro.
O sea, que tenemos que eliminar la "gravedad" y sustituirla por un dibujado ms
sofisticado.

Dado que el area original y la nuestra ambas ocupan 16x8 pixels, podemos 
pinchar el ratn en cualquier punto interior a esa rea para cerrar la ventan. 
El uso del ratn no cambia.
Notar que cuando se pincha el ratn en un pixel entre 0 y 15, el widget queda 
seleccionado por su cara frontal. En cambio, si pinchamos en un pixel entre 16 
y 20, equivale a pichar en la cara lateral derecha, por lo que el widget no se 
selecciona.

Gracias a la estructura orientada a widgets que usa fvwm2 es sencillo cambiar 
todos los widgets.
En unas horas ya tenamos un entorno realmente estereoscpico.
Es francamente excitante ver cmo las ventanas que estn delante, pero muy a 
la izquierda, aparecen como ladrillos de mucha profundidad. Los objetos ms 
lejanos no tienen aspecto de tridimensionalidad.

La limitacin es ahora que no podemos cambiar el punto de visin: el escritorio
es siempre el mismo.

El siguiente paso es conseguir movilidad. Imagnate que cuelgas 20 monitores 
del techo de la habitacin, y en cada monitor muestras una parte distinta del 
escritorio. Puedes moverte hacia adelante para ver con ms nitidez un monitor 
alejado, o puedes girar la cabeza para leer otro monitor que antes veas con el
rabillo del ojo. No slo eso, sino que queremos que sea posible mover las 
aplicaciones entre los monitores y cambiar su distribucin.
Para esto necesitamos un sistema de posicionamiento.
Con un HMD comercial suele venir incluido un dispositivo que detecta el giro de
la cabeza, y la posicin de sta. En total intervienen 6 coordenadas: X, Y, Z, 
giro horizontal (como cuando dices NO moviendo la cabeza), giro vertical (como 
cuando dices SI) y giro axial (como cuando ladeas la cabeza).
El primer intento era detectar los giros. La primera idea (no te ras) era atar
un hilo a la punta de la nariz y con 2 poleas unirlo a la ruedecilla del ratn 
que detecta movimiento vertical:

     techo
     __________
    O          O   <-polea V1
p   |          |
a   |          |
r   |          |   <-hilo
e  XXX         |
d  XXX         |   ____
   XXX         |  /    \
    ^          |  O    |  <-usuario
    |          +-<     |
 raton            |_/  |
                   \  /

As, al girar la cabeza en sentido vertical (como para decir SI) el ratn 
detectara el movimiento.
Un dispositivo similar servira para el giro vertical.
Como cada ratn tiene 2 ruedecillas, slo necesitamos 3 ruedecillas para todos 
los giros; es decir, 2 ratones.
Lo ms difcil fu encontrar las frmulas matemticas para calcular la posicin
de la cabeza. Si haces un giro horizontal, la ruedecilla horizontal cambia, 
pero tambin la vertical, pues la distancia desde la nariz hasta la polea V1 
cambia segn el ngulo de giro.

Olvdate por un momento de los giros anteriores: vamos a trabajar slo con el 
movimiento en 3D. Toma una esquina de tu habitacin como coordenadas (0,0,0)
Para simplificar, suponte que la habitacin mide 1 metro en las 3 dimensiones.
Cualquier punto del cuarto tiene coordenadas X,Y,Z todas >=0 y <=1
ahora pones 3 poleas en los puntos (0,0,1) , (0,1,0) y (1,0,0) 

      | (0,1,0)
      |Y
      |
      0___X__ (1,0,0)
      /
    Z/
    /
   /(0,0,1)

En cada polea pones una cuerda, y atas las tres a la punta de un bolgrafo. 
En el otro extremo pones un peso y entre el peso y la polea pones una vuelta 
alrededor de la ruedecilla del ratn:

  __________
  O        O <-polea
  |         \
  |          \
  @ <-rueda   \
  |            x <-boligrafo
  |
XXXXX
XXXXX <-peso
XXXXX

Ahora puedes mover el bolgrafo en 3D y las ruedecillas de los ratones girarn.
Para saber cul es la posicin de la punta del bolgrafo hay que saber lo que 
ha girado cada rueda, por ejemplo x1, y1, z1.
Ahora se trata de calcular el punto x0,y0,z0 tal que:
-la distancia entre (x0,y0,z0) y (1,0,0) es igual a x1
-la distancia entre (x0,y0,z0) y (0,1,0) es igual a y1
-la distancia entre (x0,y0,z0) y (0,0,1) es igual a z1

Esto es una simple matriz de 3x3 con solucin nica.

Notar que sto slo resuelve el movimiento pero no el giro: si mueves el 
bolgrafo manteniendo fija la punta, las ruedecilas no detectan movimiento.

Ahora bien, para combinar el movimiento y el giro necesitamos 3+3 ruedecillas, 
o sea, 3 ratones.
Los ms avispados se habrn dado cuenta de que una solucin aparentemente 
equivalente es atar 3 cuerdas a la punta del bolgrafo, y otras 3 al otro 
extremo. Pero en este caso nos dejamos un movimiento: el giro sobre el eje 
longitudinal (el que va desde un extremo al otro).
Pero tambin se habrn dado cuenta de que en realidad 2 de las ruedecillas son 
redundantes, pues la distancia entre los extremos del bolgrafo es siempre 
constante.
Decir que el experimento funcion tras un poco de deduccin trigonomtrica, y 
en un par de das ya tenamos hecho un programa que mostraba en la pantalla 
una cabeza movindose.
En vez de atar los hilos a la punta de la nariz los atamos a la pantalla y al 
casco que le serva de arns.

Tras hacer unas cuantas pruebas surgi otra idea interesante: ya que en 3D los 
objetos ms lejanos aparecen ms pequeos, dndole la vuelta al argumento, los 
objetos que aparecen pequeos es porque estn lejanos.
Me explico: imagnate que tomas una foto digital de un baln que est a 10 
metros. La imagen del baln mide 30x30 pixels. Acerca el baln hasta 5 metros. 
Ahora la imagen mide 60x60 pixels.
Toma un vdeo de un baln acercandose: cada vez la imagen es mayor.

Coloca la cmara en una esquina de la habitacin, y sita una pelota de tenis 
sobre tu cabeza. A medida que te acerques a la cmara, la imagen de la pelota 
aparece ms grande.
Ahora coloca 3 camaras en 3 esquinas, y la pelota en el centro. La imagen 
aparece de 20x20 pixels en las 3 cmaras. A medida que acercas la pelota a una 
de las cmaras, aparece ms grande.
Esto da una idea d eque es posible calcular la posicin y la distancia, basada 
en el tamao fotografiado.

Con esto nos evitamos todo el lio de hilos por toda la habitacin. A cambio 
necesitbamos 3 cmaras digitales conectadas al ordenador y capaces de 
transmitir vdeo, pero esto result ms barato de lo que pensbamos, porque 
encontramos a gente que tena modelos antiguos.
Ahora se trataba de hacer un programa que tomara la imagen digital, ubicara la 
pelota dentro de la imagen, y calculara su tamao y posicin.

Para esto hubo que entender los programas de captura de imgenes. Nuestras 
cmaras son QuickCam-Pro-3000 . Con una resolucin 640x480, es ideal para 
nuestros propsitos. Slo se consiguen 5 imagenes por segundo de vdeo, pero 
como apenas hay cambios en la imagen capturada, la compresin realizada 
internamente por la cmara resulta ser bastante eficaz.
La conexin es USB por lo que necesitamos 3 puertos.
Lo malo es que el driver que hay que usar es pwc Philips USB 
(http://www.smcc.demon.nl/webcam) para un kernel 2.4 pero parece haber un 
problemadebido a las licencias de uso. Tambin usamos otros drivers 
(http://www.saillard.org/linux/pwc) para el kernel 2.6 que funcionan de miedo.

Como las cmaras estaban fijas, pudimos calcular la posicin de la pelota.
La pelota es esfrica, as que era imposible saber cundo se habia realizado 
un giro sin movimiento. Una solucin era usar 2 pelotas, pero otra ms sencilla
era usar un cubo, con cada una de las caras de un color distinto.

Usamos para ello colores puros y brillantes para cada cara: rojo, verde, azul, 
amarillo, azul claro, rosa.
-Tomamos una imagen de cada cmara.
-Hacemos que encuentre el cubo (de 10x10x10 cm, colocado a 10 cm. de la cabeza)
-Localiza las 3 caras visibles (cada cmara slo puede ver 3 lados del cubo)
-Encuentra las esquinas, con lo que ya tenemos su posicin.
-Localiza el punto medio de las caras.
-Calcula la distancia a las esquinas, y deduce el tamao.


Colocamos una cmara en cada eje, apuntando a las paredes px, py, pz

      | (0,1,0)
      |Y   pz
      |
  px  0___X__ (1,0,0)
      /
    Z/   py
    /
   /(0,0,1)


De nuevo, basta combinar los datos de las 3 cmaras y unos clculos 
trigonomtricos que tansforman los datos anteriores en coordenadas 3D.
La siguiente idea fue todavia mejor: en vez de poner el cubo sobre la cabeza, 
construimos un cubo mayor, de 25x25x25 centmetros y metimos la cabeza dentro.
Al ser el cubo mayor, los clculos eran ms exactos. Las cmaras podan ubicar 
rpidamente el cubo tomando un muestreo cada 20 pixels, y dentro de la caja la
nica luz proviene de la pantalla TFT, con lo que no hay interferencias con el 
mundo real.
Eso s, resulta muy gracioso ver a un tipo con una caja de colores en la cabeza
movindose por la habitacin.

Tras la diversin, el trabajo. Ahora tenamos que conseguir coordinar el 
escritorio con la posicin de la cabeza, y la direccin de la mirada.
El entorno de trabajo pasa a ser una esfera con 360 grados en caja eje.
Tenamos que decirle a fvwm2 que desplazara el escritorio hacia los lados y 
hacia arriba y abajo. Como cada objeto (icono, ventana, ...) tiene unas 
coordenadas x,y de tipo int, podemos poner un valor mximo de 32768 y hacer un 
escritorio virtual de hasta 32768 pixels.

Cada marco puede dibujar 512 pixels a una distancia a los ojos de 10 cm, lo que
implica que cada pixel parece que ocupa 2 mm si se viera a 1 metro de 
distancia, que es bastante buena resolucin.
Una esfera de 1 metro de radio tiene un permetro de 2*3.14*1 = 6.28 metros lo 
que dividido por 2 milimetros da un total de 3140 pixels. Un escritorio de 
3000x3000 es bastante grande, ?no crees?

Para hacer que se desplazara el escritorio de acuerdo con el movimiento de la 
cabeza hay que investigar las rutinas que se encargan de mover todas las 
ventanas en fvwm2. Descubrimos que ya estaba incorporada la posibilidad de 
disponer de un escritorio virtual, y simplemente hay que mover la "ventana" a 
travs de la cual se ve el rea adecuada.
Moviendo el ratn cerca de los bordes, el escritorio se desplaza. En nuestro 
caso hubo que sustituir el movimiento del ratn por las coordenadas de 
situacin de la caja, dadas mediante las cmaras. El algoritmo es algo as:
-encontrar el centro de la caja, y la posicin de los ojos
-encontrar las esquinas de la caja, y la direccin en la que miran los ojos
-convertir las coordenadas x,y,z en 2 ngulos dentro de la esfera de radio 1.
 Un ngulo para el giro vertical y otro para el horizontal
-encontrar la "pgina" que corresponde a estas coordenadas esfricas
-dibujar los objetos dentro de esta ventana. Equivalentemente, mostrar el trozo
 de mega-escritorio incluido en esta ventana.
-dibujar en el otro marco los objetos vistos por el otro ojo


En la nomenclatura de fvwm2, existen varios Desktops, cada uno de MxN pginas, 
cada una del tamao de la pantalla fsica, la cual acta como un "viewport" de 
una de las pginas:

             Desk 0                     Desk 1
     +----------+----------+    +----------+----------+
     |          |          |    |          |          |
     | Page 0 0 | Page 1 0 |    |          |          |
     |          |          |    |          |          |
     |          |          |    |          |          |
     +----------+----------+    +----------+----------+
     |+--------+|          |    |          |          |
     ||Page 0 1|| Page 1 1 |    |          |          |
     ||        ||          |    |          |          |
     |+--------+|          |    |          |          |
     +----------+----------+    +----------+----------+


Nuestros cambios deben afectar al modo como se dibujan las pginas.
Todo esto lo implementamos en la rutina MoveViewport del mdulo virtual.c del 
paquete fvwm2.
Esto se encarga de redibujar todos los elementos a una nueva posicin 
(x+delta_x, y+delta_y). Nosotros debemos aadir una nueva variable global 
(marco_x,marco_y) y sumarla a los anteriores valores.
Internamente esto usa XMoveWindow con las nuevas coordenadas, o invoca a 
BroadcastPacket para aquellos elementos que no son ventanas.
En el fondo se llaman a comandos ICCCM, que es un estandar definido para 
gestores de ventanas en X-Window. Esto hace que otros gestores como twm, mwm, 
uwm, ... funcionen todos igual.

Cada objeto del escritorio adquiere unas coordenadas x,y entre 0 y 3000 dada 
inicialmente por el gestor de ventanas fvwm2. En un entorno 3D, la coordenada 
Z es nueva, y el fvwm2 no sabe cmo manejarla. Decidimos que el valor estara 
entre 0 y 3000, siendo por defecto el valor 1000 correspondiente a una 
distancia de 1 metro.
Objetos con z>2500 estaran muy lejos, y aquellos con valores z<50 estaran a 
menos de 5 cm, con lo que solo sern visibles para un ojo.

Los iconos y ventanas inicialmente se ponen con profundidad 1000 pero hicimos 
una aplicacin para poder moverlos hacia adelante y hacia atrs. No es todava 
posible girarlos; siempre estn mirando hacia el usuario. Matemticamente esto 
quiere decir que el vector normal siempre pasa por (0,0,0)

El objeto del que todava no hemos hablado result ser el ms complicado de 
manejar: el ratn.
En un entorno 2D es muy fcil, pues el ratn se puede mover tambin en slo 2 
dimensiones. Pero para mover un objeto hacia adelante o hacia atrs hace falta 
otro control. Nosotros lo solucionamos con la rueda que suelen incorporar entre
los botones, y que normalmente se usa para avanzar pginas o hacer scroll 
rpidamente.
Simplemente pinchar en un objeto, y esta rueda lo acercaba o alejaba, con lo 
que se visualizaba ms grande o ms pequeo. El comportamiento de esta rueda 
no est gobernado por fvwm, sino que X-window lo trata como un dispositivo 
independiente del ratn, mapendolo a la tecla pgina-arriba y pgina-abajo. 
As que hicimos una aplicacin que siempre se estuviera ejecutando, y que 
capture esas teclas. Luego se trata de reenviarlas a fvwm2, y ampliarlo para 
que al recibir estas teclas aumente o disminuya la profundidad del objeto 
seleccionado.

Pudimos haber usado las extensiones XKB que estn perfectamente soportadas por 
X-window, pero esto supona re-compilar las X, lo cual tarda bastante. Ms 
sencillo era modificar el mdulo del kernel que captura el ratn, y mandar los 
datos de la rueda a un nuevo dispositivo, que se puede leer con un simple pipe.
Luego con xmodmap se puede mapear a cualquier tecla, y fvwm2 permite ejecutar 
una accin cualquiera cuando se pulsa una tecla.

Esto funciona bien, expecto un detalle importante: el ratn hay que apoyarlo en
alguna parte, con lo cual no nos podemos separar mucho de l. Y resulta 
bastante incmodo manejar el ratn de espaldas cuando ests mirando en la 
direccin opuesta.
La solucin es un ratn 3D. Este cacharro consiste en un mando a distancia, y 
un receptor en la esquina de la habitacin. El dispositivo tiene 2 emisores con
2 rendijas, una horizontal y otra vertical. El receptor tiene 2 sensores. 
Cuando apuntas directamente al receptor, la seal es muy ntida, y lo 
interpreta como (0,0) . A medida que apuntas ms lejos del receptor, la seal 
es ms difusa y en funcin de la intensidad recibida sabe ms o menos a dnde 
ests apuntando.
Esto funciona bien pero hay que apuntar a un sitio cerca del receptor. Si pones
el receptor en una pared, y apuntas a la pared opuesta, no capta nada.

Lo que se nos ocurri fue hacer algo parecido a lo de la caja y las cmaras de 
video. Pintamos un dedal de color naranja fosforescente, y mediante las 3 
camaras lo ubicamos. Pero el dedal es pequeo, por lo que el tamao no cambia 
ostensiblemente. A pesar de ello logramos hacer una triangulacin bastante 
aceptable.

Una mejora de esto fue poner una pequea bombilla de luz roja en lugar del 
dedal. Ahora podamos medir la luminosidad para intentar calcular la distancia.
Lamentablemente esto obligaba a apagar las luces de la habitacin, con lo que 
las cmaras no veran la caja de la cabeza.
El dedal pintado de naranja tambin tena un inconveniente: si en la habitacion
hay algun objeto naranja en la pared, las camaras pueden confundirse.

Por eso mantuvimos la idea de la luz, pues era ms facil de localizar que el 
dedal. Una pequea bombilla alimentada por una pila colocada en el antebrazo,
que decidimos llamar dedo-luz. En ingls, finger-light, pronunciado 
"fingerlai".
Con las 3 cmaras podamos detectar exactamente la posicin, pero no el giro. 
Esto no importa nada, pues el puntero es, como su nombre indica, un objeto 
puntual.
El algoritmo de bsqueda de esta luz lo mejoramos haciendo la siguiente 
suposicin: si en un tiempo t0 la posicin es (x0,y0,z0) entonces en un tiempo 
t+dt la posicin no puede estar muy lejana de la anterior. Esto impone una 
limitacin a la velocidad con la que podamos mover el dedo-luz, pero el 
resultado era satisfactorio.

Voy a explicarlo con ms detalle: Primero supongamos una habitacion de 1 metro 
de lado.
Colocamos una cmara en una esquina del techo, apuntando a la pared opuesta.
Ajustamos el foco para que capture exactamente toda el rea de la pared.
As, si pones el dedo-luz pegado a la pared en el punto (x,y) , esta cmara 
tambin lo ve en la posicion (x,y)
Cuando lo mueves directamente hacia la cmara, sta no detecta cambios. Pero 
hay otras cmaras que s lo detectan.
Un punto (x,y,z) se ve:
-en la camara X, en el punto { y+sin(x/y), z+sin(x/z) }
-en la camara Y, en el punto { x+sin(y/x), z+sin(y/z) }
-en la camara Z, en el punto { x+sin(z/x), y+sin(z/y) }

Para encontrar (x,y,z) a partir de las imgenes de las cmaras, solo hay que 
resolver el sistema inverso de 3 ecuaciones con 3 incgnitas.

El inconveniente es que hay algunos puntos ciegos que no estn detectados por 
ninguna cmara. El caso peor es el punto (1,1,1) pero como es una esquina en el
suelo, es altamente improbable que el dedo-luz est en esa posicin.

Ahora bien, en el ratn existen al menos 2 botones. ?Cmo simularlos con el 
dedo-luz? Pues cerrando un circuito elctrico.
Colocamos el dedo-luz en el pulgar de la mano derecha. Adems le colocamos un 
cable (de 1 hilo) conectado al ordenador, y una placa metlica en el punto 1.
En el dedo ndice pusimos otra placa metlica 2 conectada al ordenador mediante
otro cable.
Enviamos electricidad por el cable 1. Cuando el pulgar y el dedo ndice se 
tocan, las placas 1 y 2 entran en contacto y el circuito se cierra, con lo que 
la corriente llega al ordenador a travs del cable del dedo ndice.
Los mismo hacemos para el dedo corazn. Ya tenemos 2 pulsadores ... digitales.


            indice  corazon
                __    __
              2/* \ 3/  \
  luz-> XX     |* |  |  |
pulgar /--\1   |* |  |  |
      |   *|   |* |  |  |
      \   *\   |* |  |  |
       \   *\__|* |  |  |
         \_ *   * |__|  |
            *    *
cable emisor*    *cable receptor


Para leer los datos enviados por el dedo-pulsador hay que conectarlo al 
ordenador de alguna manera. Podamos haber usado el puerto paralelo, pero fu 
ms sencillo usar el microfono de las webcams. Para ello sacamos el cable de la
cmara y lo conectamos a los dedo-pulsadores con una resistencia. Cuando los 
dedos se juntan, la webcam cree que est oyendo un sonido, lo cual se codifica 
y se transmite por el cable USB hasta el ordenador. Modificamos el mdulo pwc 
para leer tambin este dato, y lo metemos en otro pipe para que fvwm2 lo pueda 
leer.

Ahora s: 
-acercamos el pulgar a una ventana o un icono
-juntar el dedo ndice y el pulgar para seleccionarla ("pinchar")
-mover el pulgar (y toda la mano, claro) para arrastrarla a la nueva posicin
-separar los dedos para dejarla all

Y ahora resulta incluso ms gracioso ver a un tipo con la caja en la cabeza, 
con una luz en un dedo como ET, juntando y separando los dedos como si 
estuviera cazando mosquitos.

Otra solucin que no hemos investigado es mandar la informacin mediante 
ultrasonidos. Seguro que habis visto las llaves electrnicas que sirven para 
abrir el coche desde 5 metros. Lo que hacen es enviar un ultrasonido, que es 
detectado por un sensor dentro del coche. Pues bien, podemos poner una llave en
el dedo ndice, y otra en el corazn. Cuando se apriete el pulsador con el dedo
pulgar, lo podramos detectar. Es un tema no investigado pero plausible.

Por fin tenamos algo real para un mundo virtual.
Hicimos un cursor en 3D que se moviera de acuerdo con el dedo-luz. Esto fue 
fcil, usando XWrapPointer en X-window.
El cursor poda estar fuera del campo de visin, aunque sto no implicaba que 
el escritorio tuviera que desplazarse.
As que hubo que decirle a fvwm2 que no desplazara el escritorio cuando el 
ratn se acercase a los bordes, sino cuando cambiase el punto de visin de la 
cabeza.

Tambin cambiaba de tamao segn la distancia al observador. Incluso le hicimos
un modelado en 3D para el cursor. Todos los dems objetos eran simples 
ortoedros, pero el cursor realmente es un cono. Cuando lo ponas cercano a los 
ojos apareca grande y majestuoso: un autntico conazo.
Haba un problema cuando el dedo-luz estaba tapado por la caja o el cuerpo del 
usuario. La solucin habra sido poner ms cmaras, con lo cual se aumentara 
la exactitud del sistema. Pero no queramos gastar ms dinero, as que 
intentamos tener cuidado para que el dedo-luz nunca est cubierto por otro 
elemento fsico.

Todava falta otro elemento: el teclado. Al movernos por la habitacin es 
imposible acceder al teclado, a no ser que tengas un teclado inalmbrico y te 
lo cuelques al cuello. Esto no es adecuado. As que recordamos a Joh Mnemonic 
y decidimos hacer un teclado virtual, algo parecido al que incorpora la Palm.
Esto no es ms que una aplicacin que siempre ocupa la parte central de la 
pantalla, y dibuja teclas con fondo transparente. Pones el pulgar (en realidad 
su representacion virtual en la pantalla) para seleccionar la tecla que deseas 
pulsar, y juntndolo con el ndice se produce la pulsacin. Fcil y simple, 
pero ms complicado de usar de lo que parece. Sobre todo porque a veces 
necesitas 2 dedos para teclear. La solucin estaba al alcance de la mano. De 
la mano izquierda para ser preciso.

Montamos otro dedo-luz con una luz de color verde para el pulgar izquierdo, y 
cables para cerrar el circuito formado por el dedo ndice y el pulgar. Tambin 
para el corazon-pulgar.
Al igual que antes, las cmaras encuentran rpidamente la luz verde, convierten
sus coordenadas en una direccin 3D, y cuando detectan una "pulsacin" meten la
tecla en el pipe.
Un poco ms fcil fue sustituir el pipe por llamadas apropiadas a X-Window. En 
particular usamos XSendEvent para engaar a fvwm2 y hacerle creer que se haba 
pulsado una tecla.
Para ello seguimos el ejemplo de un driver llamado Maguellan que se usa para un
HMD profesional. Ojal pudiramos echarle un ojo y ver cmo funciona, aunque 
creemos que slo sirve para aplicaciones desarrolladas especficamente para 3D 
(como diseo de coches, aviones, ...) y no para un escritorio 3D.

Lo bueno es que ahora tenamos a un individuo en medio de la habitacin cazando
mosquitos !con las dos manos!

Una vez con el prototipo en marcha nos dedicamos a modificar los programas que 
queramos usar. El escritorio estaba aceptablemente completo, pero no hay 
muchas aplicaciones que permitan usar 3D. Por supuesto que modificamos un 
programa para representar estadisticas en 3D con curvas y grficos de barras.
Tambien hemos modificado XMRM-2.0 para hacer morphing en 3D, pero los cambios 
han sido simplemente para probar.
Si hubiera un buen programa de diseo de arquitectura, quizs lo podriamos 
adaptar.
Todava no nos hemos atrevido a convertir juegos tales como Doom a un entorno 
autntico de 3D.

Una de las ltimas mejoras ha sido el sistema de posicionamiento de la caja y 
las cmaras.
En vez de poner la caja en la cabeza y las cmaras en las paredes, hemos puesto
una cmara sobre la cabeza, y dibujado marcas en las paredes formando una 
rejilla.
La cmara est sobre la cabeza, apuntando en la misma direccin que los ojos.
En cada pared tenemos marcas cada 2 cm, con la etiqueta AB donde A indica la 
altura desde 0 hasta 2 metros, y B indica el giro, desde 0 hasta 360-1 grados.
Los que tengan estudios habrn identificado esto con la latitud y la longitud.
-La marca ms cercana al centro de la imagen capturada identifica la direccin
 en la que estamos mirando.
-La marca visible ms lejana determina la distancia desde la cmara hasta la
 pared.
-La diferencia en pixels horizontales entre una marca y otra se usa para
 averiguar la inclinacin de la cabeza.
Con esto se reduce el sistema a 1 nica camara, aunque hay que conectarla 
mediante unos cables largos desde la cableza hasta el ordenador, lo cual 
aumenta el peso que hay que llevar sobre la cabeza.
Ademas hay que elegir una cmara que tenga buena resolucin a una distancia 
entre 1 y 3 metros, para que identifique correctamente las marcas de la pared.
Y hay que dibujar marcas en toda la habitacin. En realidad la prueba la 
hicimos con post-it.

Ya que no tenamos las cmaras de la pared haba que inventar otro sistema en 
lugar del dedo-luz. Probamos con un puntero lser. La luz del lser que incide 
sobre la pared es detectada por la cmara de la cabeza siempre que estemos 
mirando en esa direccin, que suele ser lo habitual. Nadie apunta a un sitio al
que no mira.
El problema es que sabemos el punto de incidencia en la pared, pero no el 
ngulo:

rayo1
   \   |
    \  | <-pared
     \ |
      \|
-------| <-punto de incidencia
rayo2

Como se ve en el esquema, tanto rayo1 como rayo2 tienen el mismo punto de 
incidencia.
La posible solucin es tener otra cmara en la espalda que encuentre el otro 
extremo del rayo. Pero los punteros lser slo emiten luz en una direccin, no 
en los dos sentidos. Claro que podramos poner 2 punteros de distintos colores,
separados por 45 grados. Los colocamos en un guante-luz, pero result ser 
demasiado incomodo para manejarlo.
O bien mantener una de las cmaras de la pared. Posiblemente necesitaramos 2 
cmaras.

Como esto supona un gran cambio con nuevas dificultades, no le dimos ms 
vueltas y nos quedamos con el modelo antiguo de la cabeza dentro de la caja de 
colores.

Otra idea que se ha quedado por el camino ha sido la utilizacion de sonido. Si 
bien creemos que ayuda a dar sensacin de inmersin, apenas contribuye a la 
tridimensionalidad, adems de que no parece que tenga mucho que ver con un 
escritorio virtual. Quizs para juegos s que valga.
Por otro lado est el hecho de que mi amigo es sordo.

Ya que tenemos un sistema estereoscpico que muestra imgenes, hemos 
implementado otro para capturar imgenes estereoscpicas. Para ello se 
necesitan 2 cmaras de vdeo colocadas a la misma distancia de los ojos (8 cm. 
entre cada objetivo) y el foco a 1 metro. Esto es lo ms difcil de conseguir 
porque la mayora de las cmaras digitales tiene ajuste de foto automtico, y 
la distancia mnima suele ser 1.5 o 2 metros. Para hacerlo todava ms 
espectacular grabamos vdeo y luego lo mostramos en nuestros 2 marcos. El 
resultado no fue todo lo satisfactorio que esperabamos y posiblemente 
necesitemos investigar sobre este asunto. Nos atrae el tema de grabar imagenes 
reales y luego vectorizarlas para convertirlas en imagenes virtualizadas. 
Quizs entonces podramos superponer imgenes reales con virtuales, o 
superponer informacin digital sobre imgenes reales, al estilo de Robocop y lo
que se ve en los aviones de combate.

Ahora trabajamos en un guante 3D. Hemos cogido un guante negro, y pintado rayas
blancas horizontales y verticales en una trama de 2 centmetros. Con 2 cmaras 
de alta resolucin tomamos imgenes, pasamos la rejilla a 3D, y las convertimos
a un entorno virtual.
Lo malo es que la resolucin no es lo bastante buena si usamos video en tiempo 
real. Y obviamente no podemos tomar fotos cada 5 segundos.
Hay un sistema que se basa en llevar un traje con puntos de colores en las 
rodillas, caderas, cintura, codos, .. 
Esos puntos se captan en una cmara, se transforman en 3D, y pueden saber cmo 
es el movimiento de una persona.
Se usa para hacer pelculas de dibujos animados en las que los movimientos son 
bastante humanoides.
Sin duda, un tema interesante.

Tambin estamos haciendo un tetris en 3D. El usuario empuja con el dedo-luz los
bloques que le caen del techo, mientras que en el suelo estn (virtualmente, se
entiende) los bloques apilados.

Intentaremos hacer un simulador de vuelo de estilo Superman, aunque por ahora 
ms bien parece Superlpez.
Hemos encontrado muchas colecciones de objetos virtuales para disear un mundo 
virtual, aunque por ahora no le vemos utilidad para nosotros.

Segun nos han comentado, un museo de cultura egipcia ofrece paseos virtuales: 
te pones unas gafas HMD y te paseas por una habitacin y ves los muebles que 
tenan los egipcios. Al parecer hay una silla real. Cuando la ves con las gafas
parece que tiene 3000 aos, pero te puedes sentar en ella. Otra buena idea.

El objetivo de tener un escritorio virtual est cumplido. Ahora bien, tanto mi 
amigo como yo somos programadores, y la herramienta que ms usamos es un editor
de texto, que sinceramente no necesita de 3D. Pero tener un escritorio de 
3000x3000 es agradable para programar.
Dado que estamos muy iusionados con nuestro desarrollo, cabe la posibilidad de 
adquirir unas gafas reales. El punto dbil de nuestro sistema es el visor 
fsico, y existen soluciones de calidad que solucionan este problema. Ahora 
esperamos a que bajen de precio.
Mira en http://www.stereo3d.com/hmd.htm para ver una lista de los sistemas 
disponibles.

Mucha ms informacin en
http://vresources.jump-gate.com/articles/vre_articles/analyhmd/analysis.htm

Quien sabe, quizs no est tan lejos el holodeck de StarTrek.

*EOF*