UTILITZACIÓ DEL

“WIIMOTE” COM A SENSOR

INALÀMBRIC “BLUETOOTH”

Memòria del projecte

d’enginyeria tècnica industrial especialitzada en electrònica.

Presentada per: Jordi Iglesias García

I dirigida per: Jordi Sellarés González

EUETIT Terrassa. Maig de 2010

~ 1 ~

ÍNDEX Pàgina

1. Introducció -------------------------------------------------------------------------- 3

1.1 Justificació del projecte ------------------------------------------------------- 3

1.2 Antecedents ---------------------------------------------------------------------- 3

1.2.1 Exemples de realitat augmentada --------------------------------- 10

1.2.2 Components fonamentals -------------------------------------------- 11

1.2.3 Visualització de R.A. ---------------------------------------------------- 11

1.2.4 Rastreig ------------------------------------------------------------------- 12

1.2.5 Dispositius d’entrada -------------------------------------------------- 13

1.2.6 CPU necessària per R.A. ------------------------------------------------ 13

1.2.7 Software ------------------------------------------------------------------- 13 1.3 Objectius -------------------------------------------------------------------------- 14 1.4 Abast del projecte ----------------------------------------------------------------- 14 1.5 Descripció general/Dissenys preliminars ----------------------------------- 14

1.5.1 Nintendo Wii Remote -------------------------------------------------- 16 1.5.2 Càmera receptora D’IR ------------------------------------------------- 16

2. Dissenys ------------------------------------------------------------------------------- 17 2.1 Metodologia emprada --------------------------------------------------------- 17

2.2 Recursos utilitzats --------------------------------------------------------------- 17

2.2.1 Software utilitzat ------------------------------------------------------- 18 2.3 Descripció del primer pas ------------------------------------------------------ 20 2.4 Descripció del segon pas -------------------------------------------------------- 35 2.5 Descripció del tercer pas -------------------------------------------------------- 39

~ 2 ~

2.6 Descripció del quart projecte -------------------------------------------------- 44 2.7 Descripció del cinquè projecte ----------------------------------------------- 51

3. Resultats -------------------------------------------------------------------------------- 55

3.1 Àmbit d’utilització ---------------------------------------------------------------- 55

3.2 Validació dels dissenys --------------------------------------------------------- 56 3.3 Descripció del funcionament --------------------------------------------------- 56 3.4 Aplicacions del projecte --------------------------------------------------------- 56

4. Comentaris finals ---------------------------------------------------------------------- 57 4.1 Pla de treball ---------------------------------------------------------------------- 57

4.2 Llista de materials --------------------------------------------------------------- 58 4.3 Pressupost ------------------------------------------------------------------------- 59 4.4 Fites aconseguides -------------------------------------------------------------- 60 4.5 Conclusions ---------------------------------------------------------------------- 60 4.6 Millores futures ------------------------------------------------------------------ 61

5. Bibliografia ---------------------------------------------------------------------------- 63 5.1 Esquemes i llistes de components ------------------------------------------- 63

5.2 Llistats de programes i llibreries --------------------------------------------- 64 5.3 “Datasheets” dels components ------------------------------------------------ 65 5.4 Documents i llibres d’interès ------------------------------------------------- 65 5.5 Pàgines Web d’interès --------------------------------------------------------- 66

~ 3 ~

1. Introducció

1.1. Justificació del projecte El món virtual, i de la realitat augmentada, avui dia li queda molt per desenvolupar, i cada dia que passa interessa més en el mercat mundial, ja que te moltísimes finalitats com explicaré d’aquí endavant. La idea de fer ús del wiimote com a sensor per representar un sèrie d’imatges virtuals en temps real, la vaig traure d’un enginyer que es diu Johnny Chung Lee, el qual ha fet molts projectes amb el Wiimote de diferents tipus ja que amb aquest controlador pots fer coses que sorprendrien. Arran d’aquí em vaig informar de les funcionalitats del Wiimote, per definir la linia de treball que volia escollir per fer aquest projecte. En aquest projecte farem ús exclusiu de la càmera infraroja de la que disposa el controlador Wii.

1.2. Antecedents

Aquest treball està lligat amb el tema de la realitat augmentada, el qual, és un terme des d’un punt de vista directe o indirecte d’un entorn físic del món real, on els elements d’aquest s'augmenten amb les imatges virtuals generades per ordinador. Es relaciona amb un concepte més general de l'anomenada realitat mediada en què una visió de la realitat es modificada (possiblement fins i tot disminuïda en comptes de augmentada) per un ordinador. Com a resultat, obtenim les funcions de la tecnologia mitjançant la millora de la percepció actual de la realitat.

En el cas de la Realitat Augmentada, l'augment s'ha convingut en temps real i en context semàntic amb els elements mediambientals, com ara els resultats esportius a la televisió durant un partit. Amb l'ajuda de la tecnologia avançada d’aquesta realitat (per exemple, afegint la visió per computador i el reconeixement d'objectes), la informació sobre el món circumdant real de l'usuari es converteix en interactiu i útil de forma digital. La informació artificial sobre l'entorn i els objectes que hi conté, poden ser emmagatzemats i recuperats com una capa d'informació a la part superior de la visió del món real.

Actualment, la recerca de realitat augmentada explora l'aplicació d'imatges generades per ordinador en seqüències de vídeo en viu com una forma d'ampliar el món real. La cerca avançada inclou l'ús de pantalles muntades al cap amb una retina virtual dedicada a la visualització, i la construcció d'ambients controlats que contenen qualsevol nombre de sensors i actuadors.

Hi ha dues definicions comunament acceptades de la Realitat Augmentada en l’actualitat.

~ 4 ~

La primera diu que la realitat augmentada:

- Combina entorn real i entorn virtual - És interactiu en temps real - Es registra en 3D

La segona descriu que hi ha un continu que va des de l’entorn real fins un entorn virtual pur. Enmig d’aquests dos entorns, hi ha Realitat Augmentada (més a prop de l’entorn real) i Virtualitat Augmentada (més a prop de l’entorn virtual). Les següents idees serien una possible millora de cara al futur en el tema de la Realitat Augmentada:

Després de pensar molt sobre la Realitat Augmentada, vaig arribar a la conclusió que estem davant del naixement d'una nova forma d'utilitzar els ordinadors i no només una moda passatgera. Vaig comprendre també que estem en els inicis de nous sistemes operatius basats en ella. Les noves generacions d'ordinadors tindran una relació amb l'usuari molt més directa i els jocs per desenvolupar seran capaços de superar àmpliament els que van intentar l'avantguarda de manera molt valenta i estoica a través de la "realitat virtual". Després de tones de caràcters que expliquen i demostren els avenços i demostracions aconseguides pel fenomen que ens convoca en aquest treball, val la pena rescatar un mínim resum del concepte, que busca ser aclaridor respecte a les possibilitats que es presenten en el camp de la realitat augmentada. Tots els exemples vistos fins aquí, que pul·lulen per la Web saturant YouTube amb imatges sorprenents, es relacionen amb una webcam o amb qualsevol altre element capaç de detectar en imatge un patró específic que provoca algun tipus de reacció en el programari dedicat que estiguem utilitzant. És a dir, davant d'una acció detectada, es produeix una reacció que es tradueix en col·locar objectes imaginaris i predefinits pel programari sobre aquests patrons. En un futur immediat, a les escoles, es podria treballar amb un aprenentatge virtual. Amb això pensareu que avui dia ja es fa un aprenentatge amb ordinadors, i que això significa un ensenyament virtual, però, jo vull anar més enllà, vull anar a un aprenentatge virtual 3D, on quasi podria sentir-se una persona dins d’aquest món virtual. Per exemple, si ens imaginem que estem en una clase de matemàtiques de primària i volem ensenyar als nostres alumnes la forma i els diferents tipus de prismes, esferes, i figures geomètriques en general, podríem fer-ho tot virtualment.

~ 5 ~

Res intel·ligent, és clar: acció i reacció, segons un patró preestablert. Podem dir-te, doncs, que la Realitat Augmentada no és cap invent sinó una aplicació que avui s'està començant a expandir i que molts programadors ens estan permetent descobrir. És un fruit que està madurant gràcies a entusiastes com tu que sempre somien amb donar aquest pas que aportarà avenços en la matèria, avenços que seran aplicables per milions de persones arreu del món. Cap a on ens porta aquesta marea incontenible? Podríem esmentar alguns pocs camps d'acció d'aquesta nova aplicació tecnològica, però abans hem d'obrir la ment i deixar sorgir un pensament lògic i coherent: els mitjans de detecció no es tanquen únicament a webcams, i les accions resultants, per tant, no s'acaben en quadradets de colors, petits monstres en 3D o mapes de carrers i de subterranis. Molt lluny d'això hi ha les aplicacions de les grans empreses: aplicacions en medicina, indústria, més oci per descomptat, arquitectura (planejament urbanístic) i tantes àrees d'aplicació com ordinadors hi hagi al món. Vegem algunes de les múltiples àrees en les que podria brillar aquesta nova i molt prometedora tendència d'aplicació dels ordinadors.

~ 6 ~

Imagina per un instant el següent escenari: dos arquitectes es reuneixen davant d'una gran pantalla tàctil muntada sobre una de les parets de l'oficina de treball i li mostren a l’intendent de la ciutat les múltiples opcions de distribució d'un complet barri a construir-se. Amb només arrossegar plantilles predefinides cap als llocs seleccionats (lots o parcel·les), podrien posar arbres, semàfors, edificis, cases de diverses plantes i, el que és millor encara, podrien estudiar el disseny interior d'aquestes cases com si estiguessin dins d'una de elles en condicions reals.

~ 7 ~

El maquetisme passaria a ser un joc equivalent a un puzle o qualsevol joc didàctic que imaginis. Els compromisos entre llums i ombres en dissenyar una casa o l'orientació respecte a l'optimització de l'energia solar serien molt més senzills en 3 dimensions que en només 2 dimensions, com és un pla. Tot i que en l'actualitat hi ha una àmplia varietat de programari que permet crear models de simulació en 3D i obtenir-ne múltiples vistes, la Realitat Augmentada ens presenta nous aspectes dinàmics de disseny que permetrien simulacions més realistes, maximitzant detalls que actualment només són visibles mentre s'executa l'obra. En el cas de les industries, en una fàbrica en aquest cas, un enginyer amb un sensor de vibració podria detectar en les canonades el cabal de líquids que flueix simplement recolzant un transductor que li retorna a la seva Llibreta les característiques del canó estudiat, les dimensions exactes i qualsevol defecte estructural que pugui estar generant-se a l'interior de les canonades analitzades: acumulació de tosca, esquerdes per fatiga dels materials, obstruccions per elements estranys en el seu recorregut i milers de dades útils que formen part del que es coneix com manteniment preventiu en una indústria. Un altres cas, el de la medicina, les pràctiques que podrien arribar a revolucionar el diagnòstic per imatge serien les associades al ultrasò. Tots hem escoltat alguna vegada parlar de les ecografies prenatals en 2D, 3D i 4D, oi? Molt bé, doncs amb la Realitat Augmentada podríem veure en un monitor al nadó a la panxa de la mare, podríem explorar, admirar i contemplar minuciosament des tots els angles possibles. Com ja vam dir anteriorment, els resultats obtinguts dependran sempre del programari natiu que carregui l'ordinador

~ 8 ~

Un cardiòleg podria disposar d'un escàner de tecnologia Doppler, amb el qual s'acostaria al pacient i, en qüestió de segons, determinaria tots els paràmetres relacionats amb el funcionament del cor: ritme cardíac, pressió arterial, problemes coronaris (calcificació i obstruccions) i altres inconvenients. Tot això amb només veure a la pantalla el cor del seu pacient en tres dimensions i en talls transversals i / o longitudinals que li permetin estudiar centímetre a centímetre nostre múscul motor com si ho tingués a les mans. Per als neuròlegs, les ressonàncies magnètiques es completarien en minuts en lloc d'hores, comparant els resultats amb models preestablerts i obtenint les dades necessàries dels pacients de manera gràfica i tridimensional. En quant a l’agricultura, sondes enterrades al lloc a sembrar donarien informació vital del sòl i la seva composició mitjançant gràfics de barres (Excel), desplegant la informació en tres dimensions: informació sobre la humitat, l'acidesa, els nutrients i les condicions necessàries per a la sembra.

En el món del transport, els navegadors (GPS) es podrien carregar amb imatges tridimensionals d'informació per al viatger: valls, serres, monuments històrics, museus, centres d'atenció de salut i totes les dades que puguin ser de gran utilitat. La funcionalitat d'aquests equips es basaria en la interacció de dades entre el dispositiu mòbil i la constel·lació de satèl·lits present en l'àrea de cobertura.

~ 9 ~

En el cas d’anar de compres a grans magatzems, el catàleg complet de productes es carregaria en els telèfons mòbils, mostrant-nos el camí més directe cap al producte que busquem. Com a informació addicional, podríem obtenir una comparativa de models, preus, vistes preliminars dels articles buscats, al costat de promocions econòmiques o productes relacionats. Per descomptat que, en retirar, podem esborrar el catàleg carregat o podem conservar per a futures compres o visites al centre comercial.

Moltes vegades s’ha parlat que en un futur hi hauran autopistes intel·ligents, cosa que s’endinsa dins d’aquest món virtual, ja que la senyalització efectiva en les bancals i al centre de la carretera serviria de guia per traçar el camí segur dins de la via de trànsit i propiciar una navegació automatitzada sense intervenció humana (o amb la mínima atenció). Els altres automòbils que circulin a la mateixa via serien reconeguts pel nostre cotxe i per la carretera. D'aquesta manera, els llocs de control i peatge tindrien una idea cabal del cabal vehicular en cada tram de l'autovia i podrien alertar i prevenir accidents fortuïts.

La llista d'aplicacions i àmbits o escenaris on podem gaudir dels beneficis que ens ofereix la Realitat Augmentada és tan àmplia i vasta que seria impossible enumerar en aquest treball. No obstant això, per ara, només hi ha patrons d'imatges quadrades o de diferents formes geomètriques que repeteixen sempre el mateix i que el que millor que fan és mostrar i moure simpàtics i cridaners objectes virtuals que només entretenen i omplen de curiositat als qui observen les imatges que inunden la web. Tot el bo encara ha d'arribar i està per realitzar-se. Els conceptes principals estan presentats i exposats perquè els programadors comencin el seu treball creatiu aportant beneficis als usuaris i perquè aquests últims puguin aprofitar aquests beneficis amb els seus telèfons mòbils i navegadors, sense esmentar les nombroses

~ 10 ~

disciplines que podrien veure's beneficiades amb aquesta tecnologia. Les grans empreses de programari que avui dominen el mercat mundial han donat els seus primers passos en aquest camp tecnològic. De vostès i de cada un de nosaltres depèn que no absorbeixin i monopolitzin també aquest incipient món que té tot donar encara. És a dir, si el que t'agrada és la programació, tingueu en compte que és un moment de la història en que la roda s'està re inventant, en què una nova forma. d'aplicar la informàtica al món real està naixent La indústria de l'oci i els videojocs es pot tornar milionària del matí a la nit, però la indústria, la medicina i qualsevol àrea on es pugui demostrar les qualitats de desenvolupador també poden portar-nos a ser part de la història gran de la informàtica aplicada.

1.2.1. Exemples Realitat Augmentada

Alguns exemples de la realitat augmentada són les línies grogues vistes en programes de televisió de partits de futbol americà, utilitzant el sistema de 1st & Ten, i el camí de color que mostra la ubicació i la direcció del disc en les emissions de televisió dels jocs d'hoquei sobre gel. Els elements del món real són el camp de futbol i els jugadors, i l'element virtual és la línia groga, que s'ha redactat sobre la imatge per ordinador en temps real. De la mateixa manera, els camps de rugbi i criquet són esponsoritzats pels seus autors mitjançant Realitat Augmentada, logotips gegants s'insereixen en els camps quan es veu a la televisió. En alguns casos, la modificació de la realitat va més enllà de simples augments. Per exemple, els anuncis poden ser bloquejats (en part o totalment) i es substitueixen per anuncis diferents. Aquests anuncis de reemplaçament és un exemple de la realitat mediada, un concepte més general que l'RA.

Un altre tipus d'aplicació de la RA, utilitza projectors i pantalles per inserir objectes en l'entorn real, la millora d'exposicions en museus, per exemple. La diferència amb una pantalla de televisió simple per exemple, és que aquests objectes estan relacionats amb el medi ambient de la pantalla o la pantalla, i que sovint són interactius. Molts videojocs de conflictes bèl·lics en primera persona, simulen el punt de vista d'algú que fa servir els sistemes d'RA. En aquests jocs pot ser utilitzada la AR per donar

~ 11 ~

instruccions visuals en una ubicació, marqui la direcció i distància d'una altra persona que no està en la línia de visió, donar informació sobre equips com ara bales restants en una arma de foc, i mostrar d'altres imatges basades en qualsevol que sigui la intenció dels dissenyadors de jocs. Això també es diu el head-up display. En algunes aplicacions actuals, com en els cotxes o avions, això sol ser un head-up display integrat en el parabrisa.

1.2.2. Components fonamentals. Els components de maquinari fonamentals de la realitat augmentada són: visualització, seguiment, dispositius d'entrada, i l'ordinador. La combinació de potents CPU, càmera, acceleròmetres, GPS i brúixola d'estat sòlid estan sovint presents en els telèfons intel·ligents moderns, que els fan possibles plataformes de realitat augmentada.

1.2.3. Visualització RA. Hi ha tres tècniques principals per mostrar la realitat augmentada: 1. Pantalla muntada al cap 2. Pantalla de mà 3. Mostra espacial

1. Pantalla muntada al cap Aquesta tècnica tracta d’una pantalla muntada al cap (HMD) que mostra imatges de llocs, tant en el món físic com en el registrat (virtual) com també objectes gràfics virtuals a través de la vista de l'usuari, del món que l’entorna. Una visió òptica a través de pantalla utilitza tecnologia mirall semi-platejat per permetre passar a través de la lent punts de vista del món físic i superposar informació gràfica que es reflecteix en els ulls de l'usuari. Els HMD han de ser rastrejats amb un grau de sis sensors. Aquesta llibertat de seguiment permet al sistema informàtic el registre de la informació virtual al món físic. El principal avantatge de la HMD AR és l'experiència immersiva per l'usuari. La informació gràfica és esclavitzada a la vista de l'usuari. Els productes més comuns

~ 12 ~

utilitzades són les següents: Microvision Nomad, Sony Glasstron, i les Pantalles E/S.

2. Pantalla de mà

Les pantalles de mà de realitat augmentada empra un dispositiu informàtic amb una pantalla petita que cap en la mà d'un usuari. Aquesta tècnica fins a la data ha empleat visions de vídeo a través de tècniques de la superposició amb la informació gràfica amb el món físic. Inicialment empra sensors com brúixoles digitals i unitats de GPS per als sis graus de llibertat de seguiment dels sensors que conté. Aquest es va traslladar a la utilització de sistemes de marcadors fiducials com el ARToolKit per al seguiment. Avui en dia els sistemes de visió, com SLAM o PTAM s'estan emprant per al seguiment. La pantalla portàtil de AR promet ser el primer èxit comercial de les tecnologies d’RA.

3. Pantalla espacial

En lloc de que l'usuari utilitzi o carregui la pantalla muntada amb al cap o com a dispositius de mà, la Realitat Augmentada espacial (SAR) fa ús de projectors digitals per mostrar informació gràfica sobre els objectes físics. La diferència clau en el SAR és que la pantalla està separada dels usuaris del sistema. Com que les pantalles no estan associades amb cada usuari, les opcions de la SAR, col·loca de forma natural fins a un cert número de grups d'usuaris, per tant permitint la col·laboració entre ells. SAR té diversos avantatges sobre les pantalles muntades al cap i dispositius de mà. L'usuari no està obligat a portar equip o fer servir la pantalla sobre els ulls. Això fa SAR, un bon candidat per al treball col·laboratiu, ja que els usuaris poden veure les cares del altres. Aquest sistema pot ser utilitzat per diverses persones al mateix temps sense haver de fer servir una pantalla muntada al cap. La realitat augmentada espacial no pateix de la limitada resolució de pantalla de la càrrega actual de les pantalles muntades al cap i dispositius portàtils. Aquest sistema basat simplement en un projector de pantalla pot incorporar més projectors per expandir l'àrea de visualització. Quan s'utilitzen dispositius portàtils, tenen una petita finestra al món per dibuixar. Un sistema SAR pot mostrar qualsevol nombre de superfícies (o finestres) en la seva configuració interna al mateix temps. La naturalesa tangible de la SAR, fa que aquesta tecnologia sigui ideal per donar suport al disseny, ja que la SAR admet una visualització gràfica i la sensació hàptica passiva per als usuaris finals. La gent és capaç de tocar els objectes físics, i és aquest procés que proporciona la sensació hàptica passiva.

1.2.4. Rastreig Mòbils moderns amb sistemes de realitat augmentada utilitzen un o més de les següents tecnologies de seguiment: càmeres digitals i / o altres sensors òptics, acceleròmetres, GPS, giroscopis, compassos d'estat sòlid, RFID, sensors sense fil. Cadascuna d'aquestes tecnologies tenen diferents nivells d'exactitud i precisió. El més

~ 13 ~

important és el seguiment de la postura i la posició del cap de l'usuari per l'augment de la vista de d’aquest. La mà o mans de l'usuari pot rastrejar, o un dispositiu d'entrada de mà podrien ser rastrejats per oferir tècniques d’interacció.

1.2.5. Dispositius d’entrada Aquesta és una qüestió actual de la investigació oberta. Alguns sistemes, com el sistema de smartphone, el telèfon es pot utilitzar com a dispositiu de punter 3D, i la posició 3D del telèfon s’actualitza a partir de les imatges de la càmera.

1.2.6. CPU necessària per R.A. Els equips basats en càmeres requereixen CPU de gran abast i considerable quantitat de RAM per a processament d'imatges de la càmera. Per a sistemes estacionaris, empren una estació de treball tradicional amb una potent targeta gràfica. La maquinaria de processament de so es podria incloure en els sistemes de realitat augmentada.

1.2.7. Software Per a una fusió coherent d’imatges del món real de la càmera i les imatges virtuals 3D, les imatges virtuals s'han d'atribuir a les ubicacions del món real visualment, de forma realista. Això vol dir que un sistema de coordenades del món real, independent de la càmera, s'ha de d’actualitzar a partir d'imatges de la càmera. Aquest procés s'anomena registre d'imatge i és part de la definició de la Realitat Augmentada. El registre de la imatge de la realitat augmentada utilitza diferents mètodes de visió per computador, majoritàriament relacionades amb el seguiment de vídeo. Molts mètodes de visió per ordinador de la realitat augmentada s'hereten de manera similar als mètodes visuals d’odometria. En general, aquests mètodes consisteixen en dues parts. En primer lloc els punts d'interès, o marcadors fiduciaris, o detectors de flux òptic en les imatges de la càmera. La primera etapa es poden utilitzar mètodes de detecció de característiques com la detecció de la cantonada, la detecció de vores o llindar i / o altres mètodes de processament d'imatges. En la segona etapa, un sistema de coordenades del món real s’actualitza a partir de les dades obtingudes en la primera etapa. Alguns mètodes assumeixen els objectes amb geometria 3D (o marcadors fiduciaris) presents en l'escena i fer ús d'aquestes dades. En alguns d'aquests casos totes les estructures d'escena 3D han d’haver sigut calculats prèviament. Si no hi ha cap supòsit sobre la geometria de l’escena 3D, s'estructura a partir de mètodes de moviment ja utilitzats amb anterioritat. Els mètodes utilitzats en

~ 14 ~

la segona etapa inclouen la geometria projectiva (epipolar), l'ajust de paquet, la representació de la rotació amb el mapa exponencial, Kalman i els filtres de partícules.

1.3. Objectius - Realitzar una interacció entre Wiiimote-PC-Projector. - Crear un software capaç d’utilitzar el Wiimote com a sensor receptor d’infraroigs, per tal de realitzar un representació virtual en temps real. - Aconseguir realitzar una actualització contínua de la posició del pla de projecció. - Representar els moviments tridimensionals del nostre pla en una pla de projecció 2D aplicant l’actualització de la posició abans esmentada.

1.4. Abast del projecte El projecte avarca la majoria del software utilitzat per a fer funcionar tant la càmera com el projector. La llibreria Wiiuse no forma part d’aquest abast ja que, esta disponible a tothom que vulgui fer-ne us. Aquesta llibreria esta en llenguatge C, i el nostre programa python, utilitza aquest programa passant-lo al llenguatge propi del programa amb una sèrie de llibreries per fer aquesta funció. Tot el muntatge del quadrilàter amb els quatre leds, connexió Wiimote-PC via bluetooth, connexió projector-PC via port sèrie a l’hora. També fem us de les llibreries Pygame per poder implementar un petit programa a l’hora de calibrar tant la càmera com el projector, les llibreries “numpy” i “scipy” que les cridarem per fer optimització de funcions quan calculem la distància real z o (‘w’) en el nostre cas.

1.5. Descripció general/Dissenys preliminars Segurament coneixeu el que es un Wiimote o en el seu defecte, comandament Wii, quan alguna persona coneguda o de la mateixa família ha adquirit la videoconsola Wii per al seu oci. Aquest instrument te un preu al voltant de 35 a 40 euros. Qualsevol persona pensaria que per a ser un simple Wiimote, es una mica car però, si aprofundim en la funcionalitat d’aquest aparell podrem observar que te un software molt treballat i sobretot complet, es a dir, realment es massa barat per a la gran varietat de funcions que pot arribar a tenir aquest comandament, y recalcar que possiblement, amb aquest preu de venta no guanyen el que inverteixen en la seva fabricació.

~ 15 ~

Wiimote es un dispositiu que es connecta via bluetooth a la videoconsola, però aquesta connexió bluetooth es lliure, es a dir, pots arribar a connectar aquest comandament a qualsevol dispositiu que tingui connexió via bluetooth. El projecte tracta de fer un software compatible entre la càmera que te incorporada el comandament y la càmera d’un projector. Necessitarem un muntatge que es basa, en una àrea de base plana quadrada, definida per 4 leds infraroigs emissors y el comandament Wii com a receptor. Aquest estarà connectat via bluetooth a un PC, amb la finalitat de rebre la senyal dels IR leds, delimitant l’àrea que nosaltres voldrem utilitzar per a que el projector, mostri la imatge desitjada només en aquesta superfície encara que el seu rang de projecció sigui molt més extens. La intenció es aconseguir desenvolupar un sistema d’interacció entre Wiimote-PC-Projector, de tal forma que es crea un tipus de seguiment de localització, que podria seguir els punts de les geometries no-rígid i projectar una sèrie d’imatges i formes amb molta precisió sobre superfícies planes, flexibles i plegables, així com obtenir un llapis. Amb això s'aconsegueix una visió comuna a les pel·lícules de ciència ficció on un individu pot crear una gran pantalla del no res amb un dispositiu de butxaca En el nostre cas realitzarem projeccions tridimensionals en temps real, on la imatge es mourà amb nosaltres gràcies al seguiment de localització d’infraroigs de la càmera del Wiimote, amb la idea de que si nosaltres ens apropem, ens allunyem, rotem i/o desplacem els leds, el projector ens dibuixi la imatge en funció del nostre moviment, interpretant l’angle, distància i posició del nostre pla, tot això en temps real. La funcionalitat del Wiimote es la de transmetre les coordenades actualitzades al projector, per a que aquest vagi traslladant la imatge a la posició on estem situats nosaltres amb el nostre pla. La superfície delimitada per els IR leds es podrà moure lliurement en l’espai , sempre dins del rang de visió del Wiimote, el qual rebrà contínuament les coordenades en unitats píxels, que ens encarregarem nosaltres en passar-les a unitats de mesura de longitud i/o posició reals, les quals, es tornaran a passar a coordenades píxels del projector per a que aquest estigui calibrat amb el Wiimote, de tal manera que el programa a realitzar, actualitzarà la posició dels leds contínuament, per a que el projector mogui la imatge sempre en la direcció y sentit on es mogui l’usuari amb els leds. Prèviament, com he dit s’haurà de calibrar tant el comandament Wii com el projector, y finalment haurem de projectar la imatge, que s’haurà de fer una translació per a que la imatge es projecti de manera adequada en la superfície. A part de la utilitat que li donarem en aquest treball al Wiimote, he d’afegir que se li pot donar infinitat de finalitats, si tens les eines i idees adequades per fer-ho, ja que te un munt de funcionalitats.

~ 16 ~

1.5.1. Nintendo Wii remote

- HID (dispositiu d'interfície humana) Bluetooth, compatible amb el joystick.

- Preu 35-40 Euros. - Càmera receptora d’IR. - Acceleròmetre.

o Dispositiu analògic (ADXL330). o Acceleròmetre de 3 eixos

lineals. o Sensibilitat: +/-3 graus. o Resolució: 8 bits/eix

o Freqüència de mostreig: 100Hz - 12 botons digitals. - Motor de vibració tàctil, 100Hz de freqüència. - Petit altaveu auditiu 4KHz (Qualitat aproximada a la

d’un telèfon). - LED’s visuals d’estat (blaus) 100Hz. - Port d’expansió (connector de 6 pins, comunicació

I2C, actua com a bluetooth amb un pont I2C. - Memòria interna (configuració de dispositius i 5KB de

memòria general. Associació Física de les dades i la identitat amb un control remot.)

- Bateries (Piles 1.5 Volts).

1.5.2. Càmera receptora d’IR

- Hardware receptor d’IR de fins a 4 punts. - Resolució: 1024x768. - Freqüència d'actualització: 100Hz. - Mida per punt: 4 bits. - Intensitat 8 bits (mode complet). - Coordenades de la caixa: 7bits x-y (mode complet). - Camp de visió horitzontal: 45 graus (rad/píxel).

~ 17 ~

2. Dissenys 2.1. Metodologia emprada

La manera en que vam començar aquest treball va ser la següent: Vam buscar el software “wiiuse” que fa referència al codi que té el Wiimote per connectar-lo amb la videoconsola i fer les seves corresponents funcions, i arran d’aquí vam anar modificant aquest programa per a la nostra conveniència i per obtenir els resultats desitjats, com són la posició dels leds en coordenades reals.

El programa inicial, sense modificacions, el vam executar des de el PC, una vegada teníem connectat el Wiimote al PC. El Wiimote reaccionava al executar el programa, de tal forma que encenia els 4 leds inferiors i mostrava per pantalla de l’ordinador, diferents dades que feien referència al Wiimote, com el percentatge de bateria que li quedava, la indicació dels leds que hi havia encesos, o els botons que se l’hi premien, la posició en coordenades píxels de fins a quatre punts infraroigs,etc. A partir d’aquí es va realitzar el programa calibra_wii on cridant la funció calcula_pos_wii implementada en un altre programa wii.py, obtenim les coordenades reals de cada punt. Seguidament calculem les dades necessàries per calibrar el projector, i fem un programa anomenat projector.py, on transformem les coordenades reals dels leds a coordenades píxels de la càmera del projector, arran d’aquí s’implementa el programa auxiliar.py per posar la pantalla en la posició inicial amb el projector, i finalment s’utilitza el un programa anomenat principal, per representar gràficament el nostre pla amb les diferents imatges a projectar, en temps real.

2.2. Recursos utilitzats

El fitxer que he comentat anteriorment l’he extret d’una pàgina dedicada només al software en C que te el Wiimote, que s’anomena ‘Wiiuse’. Per altra banda utilitzarem una fullola quadrada per situar un led infraroig a cada cantonada, amb una distància entre ells iguals per a cada costat de la fullola. Els leds aniran connectats a una pila d’1.5 volts. Utilitzarem un pen drive receptor de senyal bluetooth, a l’hora de connectar el nostre Wiimote a l’ordinador. En el moment d’agafar les coordenades en unitat de píxels, que es com treballa el Wiimote, utilitzarem un lloc on el comandament pugui estar totalment quiet. En el nostre cas utilitzarem un trípode de càmera fotogràfica.

Una vegada fets els preparatius resoldrem una sèrie de càlculs per obtenir les corresponents coordenades reals o en unitats de píxels, com més endavant s’explicarà.

~ 18 ~

Finalment necessitarem un projector el model del qual es un Benq W500 y un programa per implementar els diferents softwares que utilitzarem per manipular tant el projecte com el Wiimote i així obtenir el calibratge entre la càmera del comandament com la del projector simultàniament, a més a més d’implementar altres programes per acabar obtenint les coordenades desitjades i que les vagi re calculant automàticament.

2.2.1 Software utilitzat

• Wiiuse: Programa en llenguatge C que fa referència a la llibreria del Wiimote que connecta amb diversos controls remots de Nintendo Wii. Suporta detecció de moviment, el seguiment per infrarojos, nunchuk, comandament clàssic, i d’altres.

• SDL (Simple Direct layer): SDL és un conjunt de llibreries desenvolupades amb el llenguatge C que proporcionen funcions bàsiques per realitzar operacions de dibuixat 2D, gestió d'efectes de so i música, i càrrega i gestió d'imatges. Tot i estar programat en C, té wrappers a altres llenguatges de programació com C + +, Ada, C #, Basic, Erlang, Lua, Java, Python, etc. També proporciona eines per al desenvolupament de videojocs i aplicacions multimèdia. Una de les seves grans virtuts és que es tracta d'una biblioteca multi plataforma, suportant oficialment els sistemes Windows, GNU / Linux, MacOS i QNX, a més d'altres arquitectures / sistemes.

• OpenGL: OpenGl és una especificació estàndard que defineix una interfície de programació d’aplicacions (API) multi llenguatge i multi plataforma per a escriure aplicacions que produeixin gràfics 2D i 3D sense tenir que endinsar-nos en els càlculs matemàtics de la geometria 3D, ja que d’això ja se’n ocupa OpenGl.

OpenGL, té com a propòsit ocultar la complexitat de la interfície amb les diferents targetes gràfiques, presentant al programador una API única i uniforme. Amaga les diferents capacitats de les diverses plataformes hardware, requerint que totes les implementacions suportin la funcionalitat completa d'OpenGL (utilitzant emulació software si fos necessari). La interfície consisteix en més de 250 funcions diferents que poden utilitzar-se per dibuixar escenes tridimensionals complexes a partir de primitives geomètriques simples, com ara punts, línies i triangles. Va ser desenvolupada originalment per Silicon Graphics Inc (SGI) el 1992 [2] i s'usa àmpliament en CAD, realitat virtual, representació científica, visualització d'informació i simulació de vol. També s'usa en desenvolupament de videojocs, on competeix amb Direct3D en plataformes Microsoft Windows.

~ 19 ~

• Python: Python és un llenguatge de programació interpretat, creat per Guido van Rossum l'any 1991. Es compara habitualment amb Tcl, Perl, Scheme, Java i Ruby. En l'actualitat Python es desenvolupa com un projecte de codi obert, administrat per la Python Software Foundation. Python és considerat com la "oposició lleial" a Perl, llenguatge amb el qual manté una rivalitat amistosa. Els usuaris de Python consideren a aquest molt més net i elegant per programar. Python permet dividir el programa en mòduls reutilitzables des d'altres programes Python. Ve amb una gran col·lecció de mòduls estàndard que es poden utilitzar com a base dels programes (o com a exemples per començar a aprendre Python). També hi ha mòduls inclosos que proporcionen E / S de fitxers, crides al sistema, sockets i fins interfícies a GUI (interfície gràfica amb l'usuari) com Tk, GTK, Qt entre d'altres. Python s'utilitza com a llenguatge de programació interpretat, el que estalvia un temps considerable en el desenvolupament del programa, ja que no és necessari compilar ni enllaçar. L'intèrpret el pot utilitzar de manera interactiva, el que facilita experimentar amb característiques del llenguatge, escriure programes un sol ús o provar funcions durant el desenvolupament del programa.

• PyWiiuse: PyWiiuse es un mòdul bàsic per a que python pugui llegir la llibreria “wiiuse” utilitzant ctypes (llenguatge C).

• Numpy/Scipy: NumPy és el paquet fonamental que es necessita per realitzar computació científica amb Python. Conté entre altres coses: • Un objecte de matriu de gran abast N-dimensional • Funcions sofisticades (de radiodifusió) • Les eines per a la integració de C / C + + i codi Fortran • Àlgebra lineal útil, transformada de Fourier, i les capacitats de nombres aleatoris. A més dels seus usos científics obvis, NumPy també es pot utilitzar com un contenidor eficient multidimensional de dades genèrics. Els tipus de dades poden ser definits arbitràriament. Això permet una integració de manera transparent i ràpida amb una àmplia gamma de bases de dades. Scipy és una biblioteca de codi obert amb els algoritmes i les eines matemàtiques per al llenguatge de programació Python. SciPy conté mòduls per a l'optimització, àlgebra lineal, integració, funcions d'interpolació especial, FFT, processament de senyals i imatges, solucionadors

~ 20 ~

ODE i altres tasques comuns en la ciència i l'enginyeria. Compta amb una audiència similar a les aplicacions com Matlab, Octave GNU, i Scilab. SciPy es distribueix actualment sota la llicència BSD i el seu desenvolupament està patrocinat per Enthought.

• Pygame: Pygame és un conjunt de mòduls del llenguatge Python que permeten la creació de videojocs en dues dimensions d'una manera senzilla. Està orientat al maneig de sprites. Gràcies al llenguatge, es pot prototipar i desenvolupar ràpidament. Això es pot comprovar en les competicions que es disputen en línia, on és cada vegada més utilitzat. Els resultats poden arribar a ser professionals. També es pot utilitzar per crear altres programes multimèdia o interfícies gràfiques d'usuari. Funciona com a interfície de les biblioteques SDL.

• PyOpenGL: PyOpenGL és una multi plataforma de Python vinculada a OpenGL i APIs relacionats. La unió es crea utilitzant la versió (en Python 2.5 i posteriors) amb llibreria ctypes, i està sota una llicència molt liberal de codi obert BSD. PyOpenGL inclou suport per a OpenGL v1.1 a través de 3.2, GLU, GLUT v3.7 (i FreeGLUT), i 3 GLE. També inclou suport per a centenars d'extensions OpenGL. PyOpenGL és interoperable amb un gran nombre de biblioteques externes GUI per Python wxPython incloent, Pygame, PyGTK, i Qt. També pot utilitzar la biblioteca GLUT per proveir de finestres i mecanismes bàsics d'interfície d'usuari.

2.3. Descripció del primer pas La primera prova, va constar de l’estudi del software del Wiimote, arran d’aquí vam descobrir que tenia una opció de lectura de leds infraroigs i que a més a més et retornava les coordenades (x,y) i la distància ‘z’ dels diferents infraroigs que captava el comandament, en unitats de píxels. Un cop coneixem el funcionament de la part del software que ens interessa, procedim a fer la connexió Wiimote-PC, que es la següent:

1- Tenir un Wiimote i un dispositiu USB bluetooth, o qualsevol altre dispositiu intern o extern per poder fer connexions d’aquest tipus.

2- En el cas de tenir un dispositiu USB, instal·lar-lo si fos necessari, normalment no es demanaran els drivers.

3- Obrim el dispositiu bluetooth connectat al PC i li donem a la opció “afegir nou dispositiu” al mateix temps que prenem els botons “1” i “2” del Wiimote simultàniament. El PC ens el reconeixerà com a "Nintendo RVL-CNT-01", el

~ 21 ~

seleccionem i li donem a connectar, mantenint polsant els botons “1” i “2” fins que es connecti.

Una vegada finalitzat el procés, podrem observar que el comandament està connectat, perquè els 4 leds d’estat no deixen de parpellejar. En el programa inicial que descarreguem en el pack wiiuse, porta un programa d’exemple amb el codi wiiuse, que si el carreguem amb el nostre corresponent programa ‘python’ els primers resultats que obtenim, són els següents:

NOTA: Polsar el botó ‘up’ del Wiimote per activar la lectura de infraroigs.

El següent codi fa referència a aquest programa inicial de wiiuse: #! /usr/bin/python import PyWiiUse as wiiuse import sys import time import os from wii import calcula_pos_wii nmotes = 2 def handle_event(wmp): global log wm = wmp[0] print '--- EVENT [wiimote id %i] ---' % wm.unid, wm.btns, wm.btns_held, wm.btns_released if wm.btns: for name,b in wiiuse.button.items(): if wiiuse.is_pressed(wm, b): print name,'pressed'

~ 22 ~

if wiiuse.is_just_pressed(wm, wiiuse.button['-']): wiiuse.motion_sensing(wmp, 0) if wiiuse.is_just_pressed(wm, wiiuse.button['+']): wiiuse.motion_sensing(wmp, 1) if wiiuse.is_just_pressed(wm, wiiuse.button['B']): wiiuse.toggle_rumble(wmp) if wiiuse.is_just_pressed(wm, wiiuse.button['Up']): wiiuse.set_ir(wmp, 1) if wiiuse.is_just_pressed(wm, wiiuse.button['Down']): if wiiuse.using_acc(wm): print 'roll = %f' % wm.orient.roll print 'pitch = %f' % wm.orient.pitch print 'yaw = %f' % wm.orient.yaw Dins d’aquest ‘if’ es realitza la l’obtenció de les coordenades píxels de cada led: if wiiuse.using_ir(wm): for i in range(4): if wm.ir.dot[i].visible: print 'IR source %i: (%u, %u)' % (i, wm.ir.dot[i].x, wm.ir.dot[i].y) print 'IR cursor: (%u, %u)' % (wm.ir.x, wm.ir.y) print 'IR z distance: %f' % wm.ir.z if wm.exp.type == wiiuse.EXP_NUNCHUK: nc = wm.exp.u.nunchuk for name,b in wiiuse.nunchuk_button.items(): if wiiuse.is_pressed(nc, b): print 'Nunchuk: %s is pressed' % name print 'nunchuk roll = %f' % nc.orient.roll print 'nunchuk pitch = %f' % nc.orient.pitch print 'nunchuk yaw = %f' % nc.orient.yaw print 'nunchuk joystick angle: %f' % nc.js.ang print 'nunchuk joystick magnitude: %f' % nc.js.mag Aquí comença el main del programa i comprova que el Wiimote estigui connectat: def handle_ctrl_status(wmp, attachment, speaker, ir, led, battery_level): wm = wmp[0] print '--- Controller Status [wiimote id %i] ---' % wm.unid print 'attachment', attachment print 'speaker', speaker print 'ir', ir print 'leds', led[0], led[1], led[2], led[3]

~ 23 ~

print 'battery', battery_level def handle_disconnect(wmp): print 'disconnect' if os.name != 'nt': print 'Press 1&2' wiimotes = wiiuse.init(nmotes, [1,2], handle_event, handle_ctrl_status, handle_disconnect) found = wiiuse.find(wiimotes, nmotes, 5) if not found: print 'not found' sys.exit(1) connected = wiiuse.connect(wiimotes, nmotes) if connected: print 'Connected to %i wiimotes (of %i found).' % (connected, found) else: print 'failed to connect to any wiimote.' sys.exit(1) for i in range(nmotes): wiiuse.set_leds(wiimotes[i], wiiuse.LED[i]) wiiuse.rumble(wiimotes[i], 1) for i in range(nmotes): wiiuse.rumble(wiimotes[i], 0) wiiuse.status(wiimotes[0]) try: while True: wiiuse.poll(wiimotes, nmotes) except KeyboardInterrupt: for i in range(nmotes): wiiuse.set_leds(wiimotes[i], 0) wiiuse.disconnect(wiimotes[i]) print 'done'

A l’hora d’enviar y rebre dades, va a una velocitat molt ràpida, de nanosegons, més endavant. Les dades obtingudes són com es veu, la posició (x,y) de cada un dels quatre leds que tenim connectats. El Wiimote enumera del 0 al 3 els nostres infraroigs, aleatòriament segons capti abans uns o altres.

~ 24 ~

A tot això dir que el camp de visió de la càmera del Wiimote esta bastant limitat i que en aquesta primera prova, la lectura dels leds es comença a perdre als 2-3 metres de distància. Una vegada vam verificar que això funcionava, vam començar a buscar el mètode de transformar aquestes coordenades captades per la càmera del Wiimote, a coordenades reals (unitats de longitud). Dins del tema tan ampli com és la geometria, dins del tema de translació de plans, vam trobar com convertir aquestes coordenades píxels en reals mitjançant una homografia. Que és una homografia? Es una transformació invertible del pla projectiu real o de coordenades homogènies al pla projectiu de la càmera. Una homografia significa una transformació projectiva lineal (una transformació invertible induïda per una transformació lineal de l’espai vectorial associat, es a dir, punt per punt, línia a línia, des de el punt de vista de l’observador. En el camp de visió d’un computador, qualsevol parell d'imatges de la mateixa superfície plana en l'espai estan relacionats per una homografia (assumint un model de càmera estenopeica). Això té moltes aplicacions pràctiques, com ara rectificació de la imatge, registre d'imatges o el càlcul de moviment de la càmera (rotació i translació entre dues imatges). Una vegada que la rotació i translació de la càmera s'han extret d'una matriu d’homografia estimada, aquesta informació pot ser utilitzada per a la navegació, o per inserir models d'objectes 3D en una imatge o un vídeo, de manera que siguin prestats amb la perspectiva correcta i semblin haver estat de l'escena original. (Això s'anomena Realitat Augmentada.) Si el moviment de la càmera entre dues imatges és la rotació pura, sense translació, llavors, les dues imatges estan relacionades per una homografia (assumint un model de càmera estenopeica).

Com es pot observar a la imatge, nosaltres tenim una càmera apuntant als punts iP en

el pla. Passant les projeccions d’aquest pla al pla iP de la càmera, això queda:

iPkP ⋅=

On K es la matriu d’homografia estimada de la càmera, on inclou els valors intrínsecs d’aquesta, i P són els quatre punts amb coordenades (x,y,z) del pla real. Per tant aquesta equació trasllada els diferents punts del pla a les coordenades de la càmera.

~ 25 ~

En canvi si invertim la matriu K i la multipliquem per els nostres punts iP , es a dir

iPkP ⋅= −1 , obtindrem el vector director d’una recta per a cada un dels punts

desitjats, en “world coordinates” (coordinades reals).

Aplicant aquest concepte a les nostres coordenades, obtenim les següents equacions: - Matriu amb paràmetres intrínsecs (Matriu d’homografia estimada):

=100

0 0

0

v

u

K y

x

αγα

Sovint, [ ]1,, vu s'utilitza per representar una posició del punt de coordenades 2D en

píxels. [ ]1,,, www zyx s'utilitza per representar una posició d’un punt 3D a “world

coordinates”, es a dir, coordenades reals. En relació amb el model de la càmera estenopeica, la matriu de la càmera s'utilitza per denotar una correspondència projectiva de les World coordinates a coordenades en píxels. La matriu intrínseca conté 5 paràmetres intrínsecs. Aquests paràmetres comprenen

distància focal, format d'imatge, i el punt principal. Els paràmetres xx mf ⋅=α i

yy mf ⋅=α representen la distància focal en termes de píxels, on xm i ym són els

factors d'escala en relació a la distància píxels. Els paràmetres intrínsecs no lineals com la distorsió de les lents també són importants tot i que no es poden incloure en el model de càmera lineal descrit pel paràmetre de la matriu intrínseca. Quan una càmera s'usa, la llum de l'ambient es centra en el pla de la imatge. Aquest procés redueix les dimensions de les dades recollides per la càmera (la llum d'una escena 3D s'emmagatzema en una imatge 2D). Cada píxel en el pla de la imatge

~ 26 ~

correspon per tant a un eix de la llum de l'escena original. La triangulació de la càmera determina que la llum entrant s'associa a cada píxel de la imatge resultant. En una càmera estenopeica ideal, una simple projecció de la matriu és suficient per fer això. Amb sistemes de càmeres més complexos, els errors resultants del mal alineament de les lents i deformacions en la seva estructura pot donar lloc a distorsions més complexes en la imatge final. La projecció de la matriu de la càmera es deriva dels paràmetres intrínsecs i extrínsecs de la càmera, i és sovint es representada per una sèrie de transformacions, per exemple, una matriu intrínseca de la càmera, una matriu de 3 × 3 de rotació, i un vector de translació. La projecció de la matriu de la càmera es pot utilitzar per associar punts en l'espai de la imatge d'una càmera amb punts a l'espai 3D. Algunes persones diuen a això “calibratge de la càmera”, però molts restringeixen el termini “calibratge de la càmera” a l'estimació de paràmetres interns o intrínsecs només. Aquesta matriu serveix per passar de les "world coordinates" a les "píxel coordinates",

multiplicant per el nostre vector ( )www zyx ,, , on l’eix Z és la línia d’observació de la

càmera, per tant aquest valor és 1:

⋅⋅

=

⋅

w

w

w

w

w

w

y

x

z

zv

zu

z

y

x

v

u

100

0 0

0

αγα

...

⋅+⋅⋅+⋅+⋅

=

⋅⋅

w

wyw

wwxw

w

w

w

z

zvy

yzux

z

zv

zu

0

0

αγα

O també:

⋅+⋅

⋅+⋅+⋅

=

11

0

0

w

wyw

w

wwxw

z

zvyz

yzux

v

uα

γα

~ 27 ~

Podem invertir la matriu inicial dels valors intrínsecs:

−

⋅⋅−⋅

⋅−

100

10

1

0

00

yy

yx

y

yxx

v

uv

αα

αααγ

ααγ

α

Per fer la transformació inversa, multipliquem la matriu invertida per [ ]1,, vu , i

obtenim el nostre vector de les “world coordinates”:

=

−

+⋅⋅−

⋅⋅−⋅

11

0

00

w

w

w

w

yy

xyxyx

y

z

yz

x

vv

uvuv

αα

αααγ

αααγ

Per tant aquí tenim el vector director d’una recta:

−

+⋅⋅−

⋅⋅−⋅

1

0

00

yy

xyxyx

y

vv

uvuv

αα

αααγ

αααγ

Arreglant-lo una mica:

( )

−⋅−−−

1

0

00

y

yxx

vv

vvuu

α

ααγ

α

~ 28 ~

En funció d’un paràmetre lambda la recta és:

( )

−⋅−−−

⋅

1

0

00

y

yxx

vv

vvuu

α

ααγ

α

λ

Recuperem les “world coordinates” quan:

wz=λ

Tindrem una recta per a cada un dels quatre punts:

( )

iiy

i

yx

i

x

i

nvv

vvuu

⋅≡

−⋅−−−

⋅ λα

ααγ

α

λ

1

0

00

La idea, doncs, es obtenir iλ minimitzant la següent quantitat:

;iii nr ⋅= λ

;iijjijij nnrrr ⋅−⋅=−= λλ

;22

iijjijij nnrd ⋅−⋅== λλ

23

1

2

0

ijij

iijji

dnnQ −⋅−⋅⋅≡ ∑∑+==

λλ

On el valor absolut és:

( ) ( ) ( ) ( ) ( ) dvvvvvvuuvvuu

Q ijy

ii

y

jj

yx

i

x

ii

yx

j

x

jj −−+

−−−

+

⋅−−−⋅−

⋅−

−−

⋅= 2

2

00

2

0000 λλα

λα

λαα

γα

λαα

γα

λ

~ 29 ~

On ‘d’ es la distància de separació entre led i led. Aquesta distància variarà segons la posició de cada led, és a dir, com els quatre leds s’ordenen del número 0 al 3 i els càlculs dels vectors directors de les rectes de cada punt o led en aquest cas, es calculen de forma matricial respectivament des de el punt 0, doncs, si la posició del led inicial es la i=0 i j=1, la distància al segon led serà 0.38 metres, que es la separació que li vam posar al nostre pla, però si es calcula la recta d’un altre led, que esta per exemple en la posició i=0 i j=2 amb el led 0, i la diferencia (j-i=2), vol dir que aquest led està en diagonal amb el led inicial, per tant la distància ‘d’ a calcular seria la suma de quadrats

22 38.038.0 + .

Una vegada conegudes les dades necessàries per conèixer la posició real dels leds procedim a realitzar un software per implementar aquestes funcions. Aquest programa a realitzar, s’anomena wii.py. En aquest programa introduirem les dades numèriques necessàries per implementar les funcions abans esmentades i optimitzar-les per obtenir el resultats desitjats. Com que γ no es un valor significatiu, i no farà variar molt els resultats, l’igualem a 0.

Llavors, en aquest programa, la matriu quedarà així:

100

0

0

0

0

v

u

y

x

αα

On xx α= , yy α= , 0uu = i 0vv = .

Els valors de (x,y,u,v) els traiem de la següent forma: Situem el Wiimote a una distància fixa procurant que es mantingui estàtic, sobre alguna plataforma, en el nostre cas sobre el trípode de càmera fotogràfica del que disposem.

~ 30 ~

Dibuixem un punt en una superfície plana (full, taula, pissarra, etc.) que estigui perpendicular a on apunta la càmera i amb un punter laser subjecte al comandament, apuntem cap al punt dibuixat, de tal forma que la càmera es quedi centrada en aquell mateix punt.

A continuació dibuixem un eix de coordenades, on aquest punt serà el punt (0,0) d’aquest eix i seguidament hi posem una sèrie de punts tant en l’eix x com en l’eix y (esquerra o dreta, dalt o sota) amb la mateixa distància entre ells. Amb un element de subjecció (nosaltres utilitzem un led infraroig i una pila d’1.5 volts), traslladem aquest led per cada un dels punts dibuixats. Per a cada punt que hi estigui situat el led infraroig, i que detecti la nostra càmera, anotarem els valors obtinguts que sortiran per pantalla de l’ordinador, que representaran la posició d’aquests punts en coordenades píxels ja que s’estarà executant el programa inicial que porta el pack ‘wiiuse’, per a la obtenció de dades.

~ 31 ~

Una vegada obtingudes les coordenades dels punts de l’eix (x) i els de l’eix (y), traurem els valors de u i v fent la mitjana dels resultats obtinguts, es a dir, en l’eix (y) la mitjana de les coordenades obtingudes (y), ja que les (x) no variaran i en l’eix (x) la mitjana de les coordenades obtingudes (x), ja que en aquest cas les que no variaran seran les coordenades (y). En la següent taula podem observar les dades obtingudes, y els resultats de (u,v,fx,fy):

Posició relativa cada punt eix(x)

Eix (Y)

Posició relativa a cada punt eix (y)

Eix (X)

Coordenades (X)

Coordenades (Y)

Coordenades (X)

Coordenades (Y)

(0,0) 512 359 (0,0) 516 357

(10,0) 513 401 (0,10) 472 358

(20,0) 511 448 (0,20) 427 357

(30,0) 509 493 (0,30) 482 354

(40,0) 513 541 (0,40) 337 360

(50,0) ----- ----- (50,0) 294 358

512≅= ∑n

xu n

píxels.

13680 ≅⋅−= dzyyfy f

357≅= ∑

n

yv n

píxels.

13250 ≅⋅−= dzxxfx f

On U=512 aproximadament, que es la meitat dels 1024 píxels que té d’amplada la resolució de la càmera, i V=357, que es gairebé la meitat de 768 píxels que te la resolució de la càmera en llargària, encara que sempre hi ha una mica d’error. Per obtenir la distància focal (fx i fy), una vegada tenim la diferència de variació de píxels entre el punt final i el punt inicial, ho multipliquem per la “dz” que és la distància z que està la nostra càmera amb el pla de representació de punts. En el nostre cas la distància que utilitzem es de 3 metres, per tant la forma correcte per obtenir aquests resultats tenint en compte la forma de representació de la càmera, seria la següent, que concorda amb la imatge de sota.

33

⋅=⇒=r

xxr

x

pfx

fx

px

On:

0xxx

pf

r

x −=

Per tant, per obtenir la distància focal fy, es fa el mateix procediment:

~ 32 ~

33

⋅=⇒=r

yyr

y

pfy

fy

py

On:

0yyy

pf

r

y −=

Amb les dades obtingudes i les matrius abans esmentades, ja calculades, s’implementen les funcions en aquest programa wii.py i es cridarà com a funció en una següent etapa del projecte, més concretament en el programa calibra_wii.py. El següent codi fa referència al programa wii.py: from numpy import * from scipy.optimize import fmin from math import atan, pi def e(w, U, V): x = 1350.0 y = 1350.0 u = 512.0 v = 357.0 a = 0.000 d1 = 0.38 d2 = 0.54 Q = 0 for i in xrange(3): for j in xrange(i+1,4): DQ1 = (w[j]-w[i])*(a*v-u*y)/(x*y)-a*(V[j]*w[j]-V[i]*w[i])/(x*y)+(U[j]*w[j]-U[i]*w[i])/x DQ2 = (V[j]*w[j]-V[i]*w[i])/y-v*(w[j]-w[i])/y DQ3 = w[j]-w[i]

~ 33 ~

if j-i == 1: d = d1 elif j-i == 2: d = d2 elif j-i == 3: d = d1 else: d = 0.0 DQ = sqrt(DQ1*DQ1+DQ2*DQ2+DQ3*DQ3)-d DQ = DQ*DQ Q = Q+DQ return Q def calcula_pos_wii (U0, V0): fx = 1350.0 fy = 1350.0 u = 512.0 v = 357.0 a = 0.000 U, V = ordena(U0, V0) ## Initial parameter value w0 = [1.5, 1.5, 1.5, 1.5] ## Fitting w = fmin(e, w0, args=(U, V), maxiter=10000, maxfun=10000) x = [] y = [] for i in xrange(4): x.append(-a*V[i]/fx/fy+U[i]/fx+(a*v-u*fy)/fx/fy) y.append((V[i]-v)/fy) return (x[0]*w[0],y[0]*w[0],w[0],x[1]*w[1],y[1]*w[1],w[1],x[2]*w[2],y[2]*w[2],w[2],x[3]*w[3],y[3]*w[3],w[3]) def calcula_punts_wii (xr, yr, zr): fx = 1350.0

~ 34 ~

fy = 1350.0 u = 512.0 v = 357.0 U = [] V = [] for i in range(4): U.append(xr[i]*fx/zr[i]+u) V.append(yr[i]*fy/zr[i]+v) return (U[0],V[0],U[1],V[1],U[2],V[2],U[3],V[3]) La següent funció s’encarrega d’ordenar la posició dels leds quan li arriben al Wiimote, i es parteix de U i V, que son les coordenades en el sensor del controlador Wii. Llavors es calcula el promig dels quatre punts i una vegada tenim les coordenades d’aquest punt promig, es calcula el vector que va des de aquest punt fins a cada un dels quatre punts dels leds. Seguidament es calcula l’angle de cadascun d’aquest vectors en coordenades polars i ordenem els punts en el sentit dels angles creixents. Això es fa per assegurar-se de que la recepció dels infraroigs es fa de forma ordenada. def ordena (U0,V0): u = 0 v = 0 for i in xrange(4): u = u + U0[i] v = v + V0[i] u = u/4 v = v/4 Ucm = [] Vcm = [] for i in xrange(4): Ucm.append(U0[i] - u) Vcm.append(V0[i] - v) angle = [] for i in xrange(4): if Ucm[i] == 0: if Vcm[i] > 0: dmy = pi/2.0 else: dmy = 3.0*pi/2.0 else:

~ 35 ~

dmy = atan(float(Vcm[i])/float(Ucm[i])) if Ucm[i] < 0: dmy = dmy + pi if dmy<0: dmy = dmy + 2*pi angle.append((dmy, U0[i], V0[i])) angle = sorted(angle, reverse=True) U=[] V=[] for i in xrange(4): U.append(angle[i][1]) V.append(angle[i][2]) return U,V

2.4. Descripció del segon pas En el programa calibra_wii.py, cridem a la funció calcula_pos_wii, que es la funció implementada en l’apartat anterior per calcular la posició en coordenades reals dels quatre punts dels que disposem (x, y, z). En el moment que el Wiimote detecti els 4 leds al mateix temps, s’imprimirà per pantalla les coordenades que volem obtenir. A continuació, es mostren el resultats trets directament per pantalla: IR source 0: (730, 150) IR source 1: (251, 160) IR source 2: (744, 627) IR source 3: (263, 642) IR cursor: (265, 110) IR z distance: 543.895630 (píxels) IR position0: (0.127331, -0.124475, 0.911485) IR position1: (-0.185802, -0.189462, 0.911212) IR position2: (0.165517, 0.173364, 0.913196) IR position3: (-0.110951, 0.114961, 0.9270350) Distància z real: 0.9 metres. IR source 0: (694, 611) IR source 1: (313, 623) IR source 2: (684, 235) IR source 3: (305, 241)

~ 36 ~

IR cursor: (267, 143) IR z distance: 641.811035 (píxels) IR position0: (0.156324, 0.194976, 1.099425) IR position1: (-0.115937, 0.139241, 1.125726) IR position2: (0.101108, -0.137588, 1.132434) IR position3: (-0.158672, -0.123431, 1.104834) Distància z real: 1.1 metres. IR source 0: (650, 257) IR source 1: (343, 263) IR source 2: (659, 563) IR source 3: (348, 572) IR cursor: (268, 129) IR z distance: 715.941406 (píxels) IR position0: (0.102794, -0.1294601, 1.323455) IR position1: (-0.153342, -0.124109, 1.312889) IR position2: (0.150337, 0.133063, 1.309057) IR position3: (-0.121496, 0.139276, 1.338259) Distància z real: 1.3 metres. Com es pot observar, les coordenades de cada “IR position”, són (x, y, z) respectivament, i si agafem per exemple l’últim cas, la distància ‘z’ real, a la que estava situada el Wiimote del nostre pla de punts, era d’1.3 metres, i les 4 coordenades z dels 4 leds infraroigs, donaven al voltant de 1.32 metres aproximadament, per tant cal dir que els valors de (u, v, Fx i Fy) trets, són els correctes ja que l’error que hi ha es de 1 o 2 centímetres com a molt. Les coordenades (x, y) de cada punt “IR position” delimiten la posició dins d’un eix de coordenades, i com podem observar, els valors son bastant coherents a l’hora de donar la posició en la que es troben.

~ 37 ~

El següent codi fa referència al programa calibra_wii.py: #! /usr/bin/python import PyWiiUse as wiiuse import sys import time import os from wii import calcula_pos_wii nmotes = 2 def handle_event(wmp): global log wm = wmp[0] print '--- EVENT [wiimote id %i] ---' % wm.unid, wm.btns, wm.btns_held, wm.btns_released if wm.btns: for name,b in wiiuse.button.items(): if wiiuse.is_pressed(wm, b): print name,'pressed' if wiiuse.is_just_pressed(wm, wiiuse.button['Up']): wiiuse.set_ir(wmp, 1) Aquest if l’hem modificat, del programa original per a que quan el Wiimote estigui rebent informació aquesta la guardi en un fitxer ‘txt’ quan polsem el botó ‘down’, així resulta més fàcil l’estudi de les dades obtingudes, ja que la recepció de dades es molt ràpida. if wiiuse.is_just_pressed(wm, wiiuse.button['Down']): U=[] V=[] for i in range(4): if wm.ir.dot[i].visible: log.write('IR source %i: (%u, %u)' % (i, wm.ir.dot[i].x, wm.ir.dot[i].y)) log.write('\n') U.append(wm.ir.dot[i].x) V.append(wm.ir.dot[i].y) log.write('IR cursor: (%u, %u)' % (wm.ir.x, wm.ir.y)) log.write('\n') log.write('IR z distance: %f' % wm.ir.z) log.write('\n') if len(U) == 4:

~ 38 ~

log.write('IR position0: (%f, %f, %f) \nIR position1: (%f, %f, %f) \nIR position2: (%f, %f, %f) \nIR position3: (%f, %f, %f)\n' % calcula_pos(U, V)) wiiuse.set_ir(wmp, 0) U = [] V = [] if wiiuse.using_ir(wm): for i in range(4): if wm.ir.dot[i].visible: print 'IR source %i: (%u, %u)' % (i, wm.ir.dot[i].x, wm.ir.dot[i].y) U.append(wm.ir.dot[i].x) V.append(wm.ir.dot[i].y) print 'IR cursor: (%u, %u)' % (wm.ir.x, wm.ir.y) print 'IR z distance: %f' % wm.ir.z En aquest ‘if’ es crida a la funció calcula_pos_wii que s’encarrega de passar de coordenades de la càmera Wiimote a coordenades reals. Aquesta funció com ja he dit està en el programa wii.py. if len(U) == 4: print 'IR position0: (%f, %f, %f) \nIR position1: (%f, %f, %f) \nIR position2: (%f, %f, %f) \nIR position3: (%f, %f, %f)' % calcula_pos_wii(U, V) def handle_ctrl_status(wmp, attachment, speaker, ir, led, battery_level): wm = wmp[0] print '--- Controller Status [wiimote id %i] ---' % wm.unid print 'attachment', attachment print 'speaker', speaker print 'ir', ir print 'leds', led[0], led[1], led[2], led[3] print 'battery', battery_level def handle_disconnect(wmp): print 'disconnect' if os.name != 'nt': print 'Press 1&2' log = open("dades.dat", "w") wiimotes = wiiuse.init(nmotes, [1,2], handle_event, handle_ctrl_status, handle_disconnect) found = wiiuse.find(wiimotes, nmotes, 5) if not found: print 'not found' sys.exit(1)

~ 39 ~

connected = wiiuse.connect(wiimotes, nmotes) if connected: print 'Connected to %i wiimotes (of %i found).' % (connected, found) else: print 'failed to connect to any wiimote.' sys.exit(1) for i in range(nmotes): wiiuse.set_leds(wiimotes[i], wiiuse.LED[i]) wiiuse.rumble(wiimotes[i], 1) for i in range(nmotes): wiiuse.rumble(wiimotes[i], 0) wiiuse.status(wiimotes[0]) try: while True: wiiuse.poll(wiimotes, nmotes) except KeyboardInterrupt: for i in range(nmotes): wiiuse.set_leds(wiimotes[i], 0) wiiuse.disconnect(wiimotes[i]) print 'done' log.close()

2.5. Descripció del tercer pas El següent pas és aconseguir obtenir la distància focal del projector, i per fer-ho utilitzarem el programa calibra_projector.py. En primer joc implementem un petit programa amb la ajuda d’unes llibreries que te el python, anomenades “Pygame”.

Pygame es un conjunt de mòduls del llenguatge Python que permeten la creació de videojocs en dos dimensions d’una manera senzilla. Està orientat al maneig de sprites. Els sprites són un tipus de mapa de bits dibuixats a la pantalla de l’ordinador per hardware gràfic especialitzat sense càlculs addicionals de la CPU.

Gràcies a aquest llenguatge, es pot fer un prototip i desenvolupar ràpidament. Això es pot comprovar en les competicions que es disputen online, on cada cop es més utilitzat. Els resultats poden arribar a ser professionals. També es poden utilitzar per crear altres programes multimèdia o interfícies gràfiques d’usuari.

~ 40 ~

Funciona com a interfície de las biblioteques SDL. Aquesta aplicació és totalment gratis, i es pot descarregar en la pàgina de Pygame. La finalitat d’aquest nou fitxer anomenat calibra_projector.py, es la de crear una pantalla auxiliar “FULLSCREEN”, es a dir que ocupi la resolució màxima de la pantalla on estiguis executant aquest fitxer, i que a més a més ens dibuixi una sèrie de punts amb la mateixa distància entre ells (distància en píxels), en diferents direccions, sempre des de un punt fix que li imposem com a punt inicial (0,0). En aquest cas, la pantalla que nosaltres utilitzem te una resolució de (1024x768) per tant el punt (0,0) agafarem el (512,384). A partir d’aquí dibuixem un número de punt bastant ampli, de 10 a 15 per cada direcció seran suficients. En el nostre cas agafem 13 punts en direcció cap a la dreta del punt inicial y 13 punts en direcció cap avall del punt inicial. En les coordenades (x) entre punt i punt deixem una distància de 30 píxels, i en les coordenades (y) deixem 20 píxels de distància entre punt i punt, ja que les resolucions de les pantalles sempre tenen més amplada que llargària.

Amb un element de subjecció (nosaltres utilitzem una vara amb un led infraroig i una pila d’1.5 volts), traslladem aquest led per cada un dels punts dibuixats en la pantalla de l’ordinador, que en aquest moment ha d’estar projectant el projector a la paret o lloc de projecció. El Wiimote en aquest instant ha d’estar fixa en algun lloc pla, apuntant on apunta el projector, amb el punts dibuixats. Nosaltres utilitzem el trípode de càmera fotogràfica ja esmentat anteriorment per subjectar el nostre comandament i que no es mogui. Per a cada punt que hi estigui situat el led infraroig, i que la càmera detecti, anotarem els valors obtinguts, que seran les coordenades en píxels.

~ 41 ~

En aquest cas és el mateix procediment que quan es calibra el Wiimote. Per agafar les dades de cada punt s’estarà executant el programa calibra_wii. Com es pot observar, en l’eix (x), la distància real es de 48.4 centímetres i en l’eix y de 32.4 centímetres, on la distància en píxels (unitats de la càmera) són 390 i 260 píxels respectivament. La distància ‘z’ real que posem des de el projector al pla de projecció es de 257 centímetres, distància en la que la imatge que projectem està ampliada al màxim possible de les capacitats del projector i la altura de la imatge coincideix amb els límits d’alçada del pla de projecció. En el nostre cas, utilitzem la pissarra com a pla de projecció.

.20704.48

390257257 píxelsfx

x

pfx

d

x

fx

P

r

x

z

rx ≅⋅=⇒⋅=⇒=

píxelsfyy

pfy

d

y

fy

P

r

y

z

ry 20624.32

260257257 ≅⋅=⇒⋅=⇒=

Per tant, la distància focal del projector es aproximadament 2065 píxels. El següent codi fa referència al programa calibra_projector.py: #!/usr/bin/python import sys,pygame from pygame.locals import*

~ 42 ~

Aquest programa s’implementa mitjançant el mòdul pygame. screen = pygame.display.set_mode((0,0), FULLSCREEN ) print pygame.display.list_modes() screen.fill((255,255,255)) El primer punt a dibuixa, es el punt centre, en comú per a les dos direccions en les que es dibuixen els punts. pygame.draw.circle(screen,(0,0,0),(512,384),4) pygame.draw.circle(screen,(0,0,0),(512,404),4) pygame.draw.circle(screen,(0,0,0),(512,424),4) pygame.draw.circle(screen,(0,0,0),(512,444),4) pygame.draw.circle(screen,(0,0,0),(512,464),4) pygame.draw.circle(screen,(0,0,0),(512,484),4) pygame.draw.circle(screen,(0,0,0),(512,504),4) pygame.draw.circle(screen,(0,0,0),(512,524),4) pygame.draw.circle(screen,(0,0,0),(512,544),4) pygame.draw.circle(screen,(0,0,0),(512,564),4) pygame.draw.circle(screen,(0,0,0),(512,584),4) pygame.draw.circle(screen,(0,0,0),(512,604),4) pygame.draw.circle(screen,(0,0,0),(512,624),4) pygame.draw.circle(screen,(0,0,0),(512,644),4) pygame.draw.circle(screen,(0,0,0),(542,384),4) pygame.draw.circle(screen,(0,0,0),(572,384),4) pygame.draw.circle(screen,(0,0,0),(602,384),4) pygame.draw.circle(screen,(0,0,0),(632,384),4) pygame.draw.circle(screen,(0,0,0),(662,384),4) pygame.draw.circle(screen,(0,0,0),(692,384),4) pygame.draw.circle(screen,(0,0,0),(722,384),4) pygame.draw.circle(screen,(0,0,0),(752,384),4) pygame.draw.circle(screen,(0,0,0),(782,384),4) pygame.draw.circle(screen,(0,0,0),(812,384),4) pygame.draw.circle(screen,(0,0,0),(842,384),4) pygame.draw.circle(screen,(0,0,0),(872,384),4) pygame.draw.circle(screen,(0,0,0),(902,384),4) # Actualitzem pygame.display.flip()

~ 43 ~

# Bucle principal while 1: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() if event.type == KEYDOWN: print str(event.unicode) print str(event.key) if event.type == MOUSEMOTION: print str(event.pos) print str(event.rel) print str(event.buttons) if event.type == MOUSEBUTTONDOWN: print str(event.pos) print str(event.button) A l’hora de trobar la posició de projecció del projector i poder calibrar-lo, utilitzarem un software similar al que utilitzem per traure la posició dels leds amb el Wiimote, amb el nom de projector.py. Tenim la nostra matriu del projector:

=

⋅

11100

0

0

v

u

ry

rx

vpfy

upfx

... I queda així:

+⋅

+⋅

=

11

vpzr

fyyr

x

upzr

fxxr

v

u

i

i

i

i

Amb aquesta matriu calculem la posició en la que esta projectant contínuament el projector. Definim aquesta funció per fer la crida com a calcula_pos_projector.

~ 44 ~

Els valors de fy i fx són 2065 píxels i up, vp tenen com a valor el punt (0,0) que es 512 i 384 respectivament. El següent codi fa referència al programa projector.py: from numpy import * def calcula_pos_projector(xr, yr, zr): fx = 2065 fy = 2065 up = 512 vp = 384 Transformació de les coordenades reals a coordenades del projector: X = [] Y = [] for i in range(4): X.append(xr[i]*fx/zr[i]+up) Y.append(yr[i]*fy/zr[i]+vp) return (X[0],Y[0],X[1],Y[1],X[2],Y[2],X[3],Y[3])

2.6. Descripció del quart pas El següent programa te com a finalitat, fer que el pla amb els leds i els quatre punts que dibuixa estiguin situats en el mateix lloc, es a dir, els 4 punts projectats amb la mida que te el nostre pla amb els leds, estiguin a sobre d’aquests respectivament. A aquest programa li anomenem auxiliar.py. A l’hora de cridar la funció calcula_pos_projector, com a valors de xr[i] i yr[i], li enviem la distància i posició en un eix de coordenades des de el punt centre del nostre taulell amb leds. Xr i yr queden així: xr = [-0.19,-0.19,0.19,0.19] yr = [-0.19,0.19,-0.19,0.19] On 0.19 es la distància tant vertical com horitzontalment des de el centre a cada un dels leds. Zr és la distància a la que està el projector per tant queda d’aquesta manera:

~ 45 ~

zr = [1.5, 1.5, 1.5,1.5]

Una vegada tenim el nostre taulell col·locat en els punts que ens projecta el projector,es a dir, una vegada la pantalla està en la posició inicial de projecció utilitzem el programa punts.py, per ajustar el Wiimote a aquestes coordenades, així aconseguir tenir tant el projector com el comandament Wii senyalant les mateixes coordenades, és a dir tindrem els dos instruments calibrats. Com que aquest programa es una modificació del programa , la funció que fa, es cridar la funció calcula_pos_wii i la funció calcula_pos_projector, i així ens va traient per pantalla les coordenades tant del projector com les del Wiimote. Nosaltres movent el Comandament Wii el que haurem d’aconseguir es que per pantalla ens doni les mateixes coordenades en el Wiimote com en el projector. De fet, les coordenades del projector seran úniques, ja que romandrà quiet i es qui dibuixa al pla de projecció, els quatre punts en una determinada posició i el Wiimote es el que es mou per acoblar-se a aquestes coordenades.

Aquest software, te com a finalitat, fer l’actualització contínuament de la posició dels nostres leds, a mida que nosaltres ens movem, de tal forma que les coordenades reals (xr, yr, rz) que obtenim per cada led cridant la funció calcula_pos_wii, passaran a ser les dades necessàries per implementar la funció calcula_pos_projector, que es crida immediatament després i així obtenim les coordenades píxels del projector. Les coordenades del projector, amb l’ajuda de les llibreries ‘pygame’ abans esmentades, seran dibuixades en forma de punts de color diferent (negre, vermell, verd i blau). Així per tant podrem observar al pla de projecció a la vegada que ens movem, 4 punts movent-se al mateix temps que nosaltres. Si apropem la càmera del Wiimote als leds, podem observar com es projecten en una dimensió més gran i viceversa, quant més lluny, més s’allunya la projecció. El següent codi fa referència al programa auxiliar.py que serveix per posar la pantalla en la posició inicial.: #! /usr/bin/python import pygame from pygame.locals import* from projector import calcula_pos_projector S’introdueixen les coordenades (x, y, z) reals per posar la pantalla en la posició inicial del projector: xr = [-0.19,-0.19,0.19,0.19] yr = [-0.19,0.19,-0.19,0.19] zr = [1.43,1.43,1.43,1.43] X = [0,0,0,0]

~ 46 ~

Y = [0,0,0,0] U = [0,0,0,0] V = [0,0,0,0] Com ja he dit, la funció calcula_pos_projector, està en el programa projector i la seva funció es passar de les coordenades reals a les coordenades del projector. (X[0], Y[0], X[1], Y[1], X[2], Y[2], X[3], Y[3]) = calcula_pos_projector(xr, yr, zr) screen = pygame.display.set_mode((0,0), FULLSCREEN ) screen.fill((255,255,255)) pygame.draw.circle(screen,(0,0,0),(int(X[0]),int(Y[0])),4) pygame.draw.circle(screen,(0,0,0),(int(X[1]),int(Y[1])),4) pygame.draw.circle(screen,(0,0,0),(int(X[2]),int(Y[2])),4) pygame.draw.circle(screen,(0,0,0),(int(X[3]),int(Y[3])),4) # Actualitzem pygame.display.flip() # Bucle principal while 1: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() if event.type == KEYDOWN: print str(event.unicode) print str(event.key) if event.type == MOUSEMOTION: print str(event.pos) print str(event.rel) print str(event.buttons) if event.type == MOUSEBUTTONDOWN: print str(event.pos) print str(event.button) La segona dada dins de la funció pygame.draw.circle(), es el color que li introduïm al cercle que dibuixarà, la tercera dada son les coordenades i la quarta dada el radi que tindrà la circumferència dibuixada. El color té tres components ‘(0,0,0)’ que són (R, G, B) respectivament. El següent codi fa referència al programa punts.py:

~ 47 ~

#! /usr/bin/python import PyWiiUse as wiiuse import pygame from pygame.locals import* import sys import time import os from wii import calcula_pos_wii from projector import calcula_pos_projector nmotes = 2 xr = [0,0,0,0] yr = [0,0,0,0] zr = [0,0,0,0] X = [0,0,0,0] Y = [0,0,0,0] def handle_event(wmp): global xr, yr, zr, X, Y wm = wmp[0] print '--- EVENT [wiimote id %i] ---' % wm.unid, wm.btns, wm.btns_held, wm.btns_released if wm.btns: if wiiuse.is_just_pressed(wm, wiiuse.button['Up']): wiiuse.set_ir(wmp, 1) if wiiuse.is_just_pressed(wm, wiiuse.button['Down']): wiiuse.set_ir(wmp, 0) Modificació del programa per realitzar l’actualització de les coordenades de cada un dels leds: U = [] V = [] if wiiuse.using_ir(wm): for i in range(4): if wm.ir.dot[i].visible: # print 'IR source %i: (%u, %u)' % (i, wm.ir.dot[i].x, wm.ir.dot[i].y) U.append(wm.ir.dot[i].x) V.append(wm.ir.dot[i].y)

~ 48 ~

print len(U) Coordenades reals wii: if len(U) == 4: (xr[0], yr[0], zr[0], xr[1], yr[1], zr[1], xr[2], yr[2], zr[2], xr[3], yr[3], zr[3]) = calcula_pos_wii(U, V) # print 'IR position0: (%f, %f, %f) \nIR position1: (%f, %f, %f) \nIR position2: (%f, %f, %f) \nIR position3: (%f, %f, %f)' % (xr[0], yr[0], zr[0], xr[1], yr[1], zr[1], xr[2], yr[2], zr[2], xr[3], yr[3], zr[3]) Coordenades píxels projector: (X[0], Y[0], X[1], Y[1], X[2], Y[2], X[3], Y[3]) = calcula_pos_projector(xr, yr, zr) # print 'Projector 0: (%f, %f) \nProjector 1: (%f, %f) \nProjector 2: (%f, %f) \nProjector 3: (%f, %f)' % (X[0], Y[0], X[1], Y[1], X[2], Y[2], X[3], Y[3]) Representació gràfica dels punts (diferents colors): screen.fill((255,255,255)) pygame.draw.circle(screen,(0,0,0),(X[0],Y[0]),4) pygame.draw.circle(screen,(255,0,0),(X[1],Y[1]),4) pygame.draw.circle(screen,(0,255,0),(X[2],Y[2]),4) pygame.draw.circle(screen,(0,0,255),(X[3],Y[3]),4) pygame.display.flip() Main (programa principal): def handle_ctrl_status(wmp, attachment, speaker, ir, led, battery_level): wm = wmp[0] print '--- Controller Status [wiimote id %i] ---' % wm.unid print 'attachment', attachment print 'speaker', speaker print 'ir', ir print 'leds', led[0], led[1], led[2], led[3] print 'battery', battery_level def handle_disconnect(wmp): print 'disconnect' screen = pygame.display.set_mode((0,0), FULLSCREEN ) screen.fill((255,255,255)) pygame.display.flip() if os.name != 'nt': print 'Press 1&2'

~ 49 ~

wiimotes = wiiuse.init(nmotes, [1,2], handle_event, handle_ctrl_status, handle_disconnect) found = wiiuse.find(wiimotes, nmotes, 5) if not found: print 'not found' sys.exit(1) connected = wiiuse.connect(wiimotes, nmotes) if connected: print 'Connected to %i wiimotes (of %i found).' % (connected, found) else: print 'failed to connect to any wiimote.' sys.exit(1) for i in range(nmotes): wiiuse.set_leds(wiimotes[i], wiiuse.LED[i]) wiiuse.rumble(wiimotes[i], 1) for i in range(nmotes): wiiuse.rumble(wiimotes[i], 0) # # Per utilitzar aquesta linia canviar 'position' per 'sensitivity' a pywiiuse.py. # # wiiuse.set_ir_sensitivity(wiimotes[i], 5) wiiuse.status(wiimotes[0]) while True: wiiuse.poll(wiimotes, nmotes) for event in pygame.event.get(): if event.type == QUIT: for i in range(nmotes): wiiuse.set_leds(wiimotes[i], 0) wiiuse.disconnect(wiimotes[i]) pygame.quit() sys.exit()

~ 50 ~

Es llegeix la Wii

(Coordenades Wii)

S’obtènen les rectes per cada

punt: u(0), v(0); u(1), v(1); u(2), v(2); u(3), v(3);

Calcular la posición en l’espai real.

S’obtènen les coordenades reals:

x(0), y(0), z(0); x(1), y(1), z(1); x(2), y(2), z(2); x(3), y(3), z(3);

Projectar a l’espai del projector

S’obtenen les coordenades píxels

del proyector: X(0), Y(0) X(1), Y(1) X(2), Y(2) X(3), Y(3)

~ 51 ~

2.7. Descripció del cinquè pas En aquest últim pas, passem el codi del programa punts.py al llenguatge OpenGL. Aquest últim programa s’anomena principal.py. Aquest software, te com a finalitat, fer la mateixa funció que punt.py, es a dir, l’actualització contínua de la posició dels nostres leds, a mida que nosaltres ens movem, però a més a més implementar un codi per a que introduint les coordenades reals de la posició, OpenGL ens faci els càlculs matricials, per interpretar gràficament en 2D la posició tridimensional en la que estan situat els leds infraroigs. Pygame té la funció de crear una pantalla auxiliar de resolució màxima permesa per el monitor que s’utilitza per a que OpenGl treballi sobre ella. Així per tant podrem observar al pla de projecció a la vegada que ens movem. Si apropem la càmera del Wiimote als leds, podem observar com es projecten en una dimensió més gran i viceversa, quant més lluny, més petita es fa la projecció. Amb l’OpenGl, es crea una matriu de projecció, i amb la funció “frustum” que es on li introduïm les dades de calibració, es a dir, les coordenades reals i ell mateix ja s’encarrega de fer el càlculs. Les coordenades que l’introduïm fan referència a la posició dins un eix de coordenades, (dalt, baix, dreta i esquerra).

El següent codi fa referència al programa principal.py: #!/usr/bin/env python # Paul Furber 2001 - m@verick.co.za from OpenGL.GL import * from OpenGL.GLU import * import pygame from pygame.locals import * import PyWiiUse as wiiuse import sys import time import os from wii import calcula_pos_wii textures = [0,0] def resize((width, height)): if height==0: height=1 glViewport(0, 0, width, height)

~ 52 ~

glMatrixMode(GL_PROJECTION) glLoadIdentity() glFrustum(-5.38/2.25,5.38/2.25,-4.03/2.25,4.03/2.25,10.0,0.001) glMatrixMode(GL_MODELVIEW) glLoadIdentity() Es crida una funció per a que OpenGl representi la posició tridimensional del nostre pla en un pla 2D a l’hora de fer la projecció. def load_textures(): texturefile = join('data','nehe.bmp') textureSurface = pygame.image.load(texturefile) textureData = pygame.image.tostring(textureSurface, "RGBX", 1) glBindTexture(GL_TEXTURE_2D, textures[0]) glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, textureSurface.get_width(), textureSurface.get_height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData ); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) En aquest apartat s’inicialitzen les opcions que nosaltres volem en la representació gràfica: def init(): glEnable(GL_TEXTURE_2D) load_textures() glShadeModel(GL_SMOOTH) glClearColor(0.0, 0.0, 0.0, 0.0) glClearDepth(1.0) glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LEQUAL) glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) Aquí tenim el mateix programa que en el programa punts.py però amb la diferència que a l’hora de dibuixar el punts actualitzats en tems real utilitzem el llenguatge d’OpenGL. def handle_event(wmp): global xr, yr, zr, X, Y wm = wmp[0] print '--- EVENT [wiimote id %i] ---' % wm.unid, wm.btns, wm.btns_held, wm.btns_released if wm.btns: if wiiuse.is_just_pressed(wm, wiiuse.button['Up']):

~ 53 ~

wiiuse.set_ir(wmp, 1) if wiiuse.is_just_pressed(wm, wiiuse.button['Down']): wiiuse.set_ir(wmp, 0) U = [] V = [] if wiiuse.using_ir(wm): for i in range(4): if wm.ir.dot[i].visible: print 'IR source %i: (%u, %u)' % (i, wm.ir.dot[i].x, wm.ir.dot[i].y) U.append(wm.ir.dot[i].x) V.append(wm.ir.dot[i].y) print len(U) if len(U) == 4: (xr[0], yr[0], zr[0], xr[1], yr[1], zr[1], xr[2], yr[2], zr[2], xr[3], yr[3], zr[3]) = calcula_pos_wii(U, V) def draw(): glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) glLoadIdentity() glTranslatef(0.0, 0.0, 0.0) Dibuixem el nostre quadrilàter donant-li les coordenades reals (xr, yr, zr) tridimensionals, en un pla 2D definit per la funció ‘TEXTURE’. glBegin(GL_QUADS) glTexCoord2f(1.0, 1.0); glVertex3f(xr[0], yr[0], -zr[0]) glTexCoord2f(0.0, 1.0); glVertex3f(xr[1], yr[1], -zr[1]) glTexCoord2f(0.0, 0.0); glVertex3f(xr[2], yr[2], -zr[2]) glTexCoord2f(1.0, 0.0); glVertex3f(xr[3], yr[3], -zr[3]) glEnd() Programa principal (main): def handle_ctrl_status(wmp, attachment, speaker, ir, led, battery_level): wm = wmp[0] print '--- Controller Status [wiimote id %i] ---' % wm.unid print 'attachment', attachment print 'speaker', speaker print 'ir', ir print 'leds', led[0], led[1], led[2], led[3] print 'battery', battery_level

~ 54 ~

def handle_disconnect(wmp): print 'disconnect' def main(): Definim com a globals les variables a utilitzar: global xr, yr, zr, X, Y nmotes = 2 xr = [0,0,0,0] yr = [0,0,0,0] zr = [0,0,0,0] X = [0,0,0,0] Y = [0,0,0,0] wiimotes = wiiuse.init(nmotes, [1,2], handle_event, handle_ctrl_status, handle_disconnect) found = wiiuse.find(wiimotes, nmotes, 5) if not found: print 'not found' sys.exit(1) connected = wiiuse.connect(wiimotes, nmotes) if connected: print 'Connected to %i wiimotes (of %i found).' % (connected, found) else: print 'failed to connect to any wiimote.' sys.exit(1) for i in range(nmotes): wiiuse.set_leds(wiimotes[i], wiiuse.LED[i]) wiiuse.rumble(wiimotes[i], 1) for i in range(nmotes): wiiuse.rumble(wiimotes[i], 0) wiiuse.set_ir_sensitivity(wiimotes[i], 5) wiiuse.status(wiimotes[0]) Especifiquem que la pantalla auxiliar que pygame ens crearà, per a que OpenGL hi treballi sigui de resolució màxima d’acord amb la resolució que té el projector que s’utilitza (FULLSCREEN). video_flags = OPENGL|DOUBLEBUF|FULLSCREEN

~ 55 ~

pygame.init() pygame.display.set_mode((1024,768), video_flags) resize((1024,768)) init() frames = 0 ticks = pygame.time.get_ticks() while 1: wiiuse.poll(wiimotes, nmotes) event = pygame.event.poll() if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE): break draw() pygame.display.flip() frames = frames+1 print "fps: %d" % ((frames*1000)/(pygame.time.get_ticks()-ticks)) if __name__ == '__main__': main()

3. Resultats

3.1. Àmbit d’utilització

• Centres d’ensenyament

• Cinemes

• En el domicili de qualsevol persona.

• Centres comercials

• Cartells d’anuncis digitals

• Etc.

~ 56 ~

3.2. Validació dels dissenys Per assegurar que el pas de les coordenades píxels de la càmera a les coordenades reals eren les correctes, es van fer proves situant el Wiimote en diferents posicions, es a dir, apropant-lo, allunyant-lo, desplacen aquest cap a un costat o l’altre i mesurar amb un metre la distància que hi havia fins la mira de la càmera i comparar amb la distància z obtinguda. Per a que els valors siguin correctes, aquest depenen del valor de la distància focal que s’introdueix al programa, com també els valors d’U i V que teòricament han de ser la meitat de la resolució de la càmera. La calibració es dona per bona quan una vegada es posa la pantalla del projecció inicial, el wiimote ens treu per pantalla les coordenades introduïdes en el programa per a que ens projecti aquesta pantalla inicial. Les coordenades introduïdes són la distància que hi ha des de el punt centre del nostre pla a cada un dels nostres leds, considerant que estan dins un eix de coordenades, a més de la distància a la que es torba el projector de la pantalla de projecció. L’últim pas, que tracta l’actualització de la posició dels leds, el donem per vàlid quan la imatge es superposa sobre l’àrea definida pels nostres infraroigs i la imatge no es perd en el moment en que es fa algun moviment, o queda desenfocada. Es van agafar exemple de dibuixos tridimensionals d’OpneGL i arran d’aquí es va anant modificant poc a poc per a que no donés cap error en la projecció de la imatge, passant el codi del programa punts.py a llenguatge OpenGL per tal de projectar gràficament els nostres moviments.

3.3. Descripció del funcionament

- Muntar el portàtil i el projector. - Realitzar la connexió del Wiimote al PC via bluetooth. - Posar la pantalla en la posició inicial (auxiliar.py). - Alinear el Wiimote (punts.py o programa final principal.py) - Ja es por començar a interactuar.

3.4. Aplicacions del projecte

Podem ficar aquest treball com una aplicació dins de l’ensenyament escolar, ja que te com a finalitat la projecció d’imatges en moviment en temps real i a més tridimensionals, la qual cosa, aporta una nova forma d’impartir aquesta ensenyança i una nova manera d’interacció per als diferents alumnes. Es podria dir que seria una

~ 57 ~

bona aplicació per aquelles sessions, on els estudiants necessiten un ordinador per realitzar aquestes sessions. També podríem dir que aquesta funció es podria realitzar com una llibreta individual, on els estudiants podrien interaccionar amb les diferents figures, imatges, textos, on en un futur, amb una sèrie d’innovacions sobre aquest projecte, es podria aconseguir escriure sobre aquesta. Una altra aplicació que podem treure, es la fer animacions 3D, com per exemple la visualització de fotogrames per tal de veure un petit curt o inclús podríem realitzar petits videojocs flash o la finalitat seria moure la posició dels leds y l’objecte, persona, o qualsevol altre figura es mogui dins el nostre pla o fer una finalitat específica.

4. Comentaris finals

4.1. Pla de treball

• Connexió i verificació de la lectura dels infraroigs per part del Wiimote.

• Càlcul matemàtic de les coordenades reals, mitjançant les coordenades en píxels, de la posició dels nostres leds.

• Modificació del software principal del Wiimote per implementar la funció calcula_pos_wii i obtenir les coordenades reals.

• Obtenció de la distància focal i calibració del Wiimote mitjançant els càlculs descrits anteriorment.

• Utilització del programa calibra_projector.py per a la obtenció de la distància focal i calibració del projector.

• Crear un software per definir la funció calcula_pos_projector de la mateixa manera que la funció calcula_pos_wii per tal de cridar-la en el programa principal, utilitzant els valors de la distància focal, ‘u’ i ‘v’ tres en els passos anteriors.

• Calibració del Wiimote amb el projector mitjançant el programa auxiliar.py, col·locar els leds sobre els punts que dibuixa aquest programa i situar el Wiimote de tal forma que ens doni per pantalla les coordenades dels punts que el projector ens mostra en la pantalla mitjançant el programa punts.py.

• Actualització de les coordenades reals en temps real, implementant el software principal.py a l’hora que el pla amb els leds es mou en

~ 58 ~

diferents direccions i angles. Per tant els punts es mouran en la direcció del nostre moviment.

Aquest programa fa la mateixa funció que el punts.py però amb l’ajuda de l’OPENGL, amb una funció afegida que es la de fer la translació i rotació de les matrius projectives de les coordenades del Wiimote per a que aquest detecti les coordenades dins un pla tridimensional i que ens el projecti en un pla 2D.

4.2. Llista de materials - 2 Piles d’1.5V (No importa la marca de piles. Model AA.) - Fullola de fusta (val qualsevol superfície plana no molt gran, més o menys de 0.4x0.4 metres o inferior.)

- Cables elèctrics FCC-68 Data cables (cables comunament utilitzats en les plaques protoboard.)

- Leds infraroigs SE3455/5455 (Alimentació de fins a 1.7 V, angle de visió de 90º, diàmetre 5mm. Led de dos pins.) A l’hora de treballar amb emissions infraroges, s’ha de tenir en compte si és o no perillós per a la salut del ser humà. Aquí es resumeixen algunes idees i pensaments que es van intercanviar en el fòrum Linux / IrDA (Dispositius infraroigs). No està mèdicament estudiat, però l'especificació IrDA diu que la gamma de dispositius de IrDA s'ha limitat a 1 m per raons de seguretat per als ulls. Una altra hipòtesi plausible és que el consum d'energia i la contaminació de l'IR / interferència van ser raons d'aquesta limitació. En principi, podria haver perill per a l'ull, perquè la llum infraroja no està registrada per l'ull, per tant la pupil·la no es tancarà amb la finalitat de protegir la retina de focus de llum IR. Aquesta és la mateixa situació que amb la llum ultraviolada, cosa que provocarà ceguesa amb el temps, però en contrast amb la llum ultraviolada, la llum infraroja conté la quantitat d'energia menys nociva per la seva major longitud d'ona. Les úniques restriccions legals i consells mèdics que hem estat capaços de trobar, fan referència a les emissions infraroges de les làmpades de calor o en el procés de soldadura i IEC 825-1 (CENELEC EN60825-1). Això suggereix que la llum infraroja que emeten els dispositius de IrDA seran innocus, ja que fins i tot la potència màxima emesa per forts LEDs IR (ca. 300 MW) estan diversos ordres de magnitud per sota de la potència emesa per les làmpades mèdiques de infrarojos (fins a 500 W). Se suposa que per arribar a aquest nivell, hauríem de portar ulleres de protecció, i mirar directament a 1,000 LEDs infrarojos encesos al mateix temps. L'efecte de la llum infraroja és sobretot la calor, però, no una alteració o destrucció de l'estructura de la cèl·lula biològica, com les causades per la llum UV. Encara que per exemple, en les especificacions de la impressora HP OmniBook 800 Hewlett-Packard recomana no

~ 59 ~

mirar directament el LED infraroig. - Porta piles (2 piles d’1.5V)

- Potenciòmetre 100kΩ PIHER CP-21 (Potenciòmetre per a reduir els 3V d’entrada, a 1.7V que suporten els leds).

- Switch 12000X778 series (Interruptor per mantenir apagats els leds, ja que el consum es bastant elevat).

- Wii remote (Peça essencial per al nostre projecte. Comandament de la videoconsola Wii).

- Pen drive receptor bluetooth 2.0 EDR (Trust), (Qualsevol dispositiu bluettoth amb connexió al PC serveix).

- PC (Windows XP), (Preferible que sigui portàtil, ja que aquest projecte es pot aplicar en diferents llocs amb facilitat. Sistema operatiu Windows, encara que amb Linux també estan disponibles els arxius, així com també en mac i d’altres).

- Projector (Benq W500), (Projector 3LCD).

4.3. Pressupost COMPONENTS UNITATS PREU UNITAT

TOTAL: 1279.63 Euros

Fullola de fusta 0.4x0.4m

1 unitat 1.50 Euros

Cables elèctrics 2 metres 0.44 Euros/metre

Leds Infraroigs 5 unitats 6.95 Euros

Porta piles (2 piles) 1 unitat 1.30 Euros

Potenciòmetre 100kΩ

1 unitat 3.90 Euros

Switch 1 unitat 1 Euro

Wii remote 1 unitat 38 Euros

PC (portàtil) 1 unitat 300 Euros

Receptor bluetooth 1 unitat 15 Euros

Projector 1 unitat 878.30 Euros

Pila d’1.5V 2 unitats (4 piles Paquet)

2.5 Euros

~ 60 ~

4.4. Fites aconseguides Els objectius que es van posar al inici d’aquest treball s’han aconseguit realitzar, no satisfactòriament, perquè encara hi ha petits errors, però aquest no influeixen al funcionament del projecte greument. La connexió Wiimote_PC_Projector funciona sense problemes, la transformació de les coordenades de la càmera a coordenades reals, s’ha realitzat correctament, els programes per realitzar les calibracions són totalment correcte, l’únic problema es que si aquesta calibració es fa a mà y no amb els materials adequats per mantenir estàtics els components, sempre s’obté una mica d’error a l’hora d’obtenir les dades, encara que es un error poc significatiu. La re calculació de la posició dels emissors d’infraroigs la fa en un temps de actualització molt ràpid, es podria dir que en temps real ja que quan la imatge es superposa en el nostre pla en el moment que s’està movent, a simple vista no es veu un retard considerable. Per últim l’aplicació de l’OpenGL ens ha facilitat els càlculs matricials, i ens dona la opció de transformar els moviments en una espai tridimensional del nostre pla, a un pla 2D per poder projectar la imatge sense problemes.

4.5. Conclusions

Al llarg del treball s’han realitzat una sèrie de programes, per tal d’aconseguir el calibratge dels dos instruments més importants, que són el projector i el Wiimote, i altres programes per aconseguir un aplicació virtual amb el Wiimote. Han sorgit una sèrie d’inconvenients en la calibració, perquè no es del tot exacte, ja que no disposem dels materials suficients per fer-ho. Per tant sempre tindrem un petit rang d’error, a l’hora de representar gràficament les imatges.

El treball més complicat ha sigut el càlcul matemàtic del valors de la càmera com la forma d’aconseguir realitzar el pas de coordenades píxels a coordenades reals. S’han fet modificacions del programa inicial contínuament i s’han anat agafant les dades resultants, fins aconseguir obtenir uns resultats el més òptims possibles.

Gracies a la aplicació de l’OpenGL, ens ha facilitat molt les coses a l’hora de projectar la imatge en temps real en el món virtual, per el fet que té com a finalitat produeixin gràfics 2D i 3D sense tenir que endinsar-nos en els càlculs matemàtics de la geometria 3D, ja que d’això ja se’n ocupa OpenGl.

Per últim afegir que els resultats obtinguts han sigut no els esperats, però si que són bastant bons ja que la idea inicial que teníem sobre aquest treball es realitza correctament però no amb tota llibertat que voldríem, perquè com ja he dit anteriorment, el camp de visió i la sensibilitat del Wiimote estan limitats, encara que

~ 61 ~

en un futur això es podria millorar per tal de millorar les expectatives. Les finalitats que se li poden treure al Wiimote són moltes com també l’ús que se li pot donar als múltiples sensors del comandament és molt interessant.

La interacció entre el Wiimote-PC-Projector es molt bona, a més a més la representació gràfica de la rotació i moviment dels nostres leds, no representa retard al ull humà, i es podria dir que està totalment en temps real.

Finalment es podria dir que el software que inclou el controlador Wii, dona certa llibertat per poder experimentar amb aquest tipus de treballs, ja que inicialment ens proporciona la lectura de posició de les emissions infraroges, com també l’angle de gir, profunditat, i diferents dades dels sensors que te incorporats el Wiimote.

4.6. Millores futures

• Aplicació de la projecció d’imatges en pissarres virtuals mitjançant la interacció del Wiimote.

• Simular un videojoc, una pel·lícula o un vídeo en primera persona, mitjançant la lectura d’infraroigs situats sobre aquesta mateixa, i mentre l’individu es mou, la imatge de l’entorn virtual es mou en la mateixa direcció.

• Càmera de vigilància com a sensor de moviment, i representació gràfica de les zones on hi ha hagut moviment.

• Aplicacions militars com per exemple rada, on ens mostra en temps real els objectes que es mouen dins d’un rang de visió de la càmera, mitjançant els acceleròmetres.

• Simulació d’un GPS en temps real, mitjançant unes coordenades inicials, representació gràfica mitjançant línies del moviment que s’ha fet

• Podem afegir aplicacions fotogràfiques on les instantànies serien difícils d’obtenir, per que els objectes estan en moviment i són massa ràpids, gracies un altra cop als acceleròmetres.

• Com aquestes, moltes més aplicacions amb el comandament Wiimote fent us dels seus diferents sensors.

• Ampliació d'una pantalla de PC en l'entorn real: les finestres dels programes i les icones apareixen com a dispositius virtuals en l'espai real i són els ulls operatius o gestos, els que desplacen les finestres.

~ 62 ~

• Una sola pantalla personal (ulleres) al mateix temps podria simular un centenar de pantalles convencionals PC o aplicació de Windows en tot un usuari.

• Dispositius virtuals de tot tipus, per exemple, substitució de les pantalles tradicionals, panells de control i aplicacions totalment noves impossible en la "realitat" de hardware, com a objectes de manera interactiva en 3D canvien de forma i aspecte segons la tasca actual o la necessitat.

• Millora de les aplicacions en els mitjans de comunicació, com les pantalles virtuals pseudo hologràfiques, cinema virtual, virtual 'holodecks' (que permet imatges generades per ordinador per a interactuar amb artistes en viu i l'audiència).

• La substitució de telèfons mòbils i pantalles de navegadors de cotxe: inserció d'informació directament en el medi ambient, per exemple, orientar les línies a la carretera, així com millores com "X-ray",plantes virtuals, fons d'escriptori, vistes panoràmiques, obres d'art, decoració, il·luminació, la millora de la vida quotidiana, etc. Per exemple, una finestra virtual es podria mostrar en una paret amb regularitat que incloguin una transmissió en viu d'una càmera col·locada a l'exterior de l'edifici, el que permet a l'usuari canviar eficaçment la transparència d'una paret.

• Amb els sistemes d'AR dins el mercat, podem veure finestres virtual, cartells, senyals de trànsit, adorns nadalencs, torres de publicitat i molt més. Aquests poden ser totalment interactius, fins i tot a distància, pels ulls apuntant per exemple.

Qualsevol dispositiu físic que actualment es produeixen per ajudar en tasques orientades a dades (com el rellotge, la ràdio, el PC, l'arribada i taula de sortida en un aeroport, de cotització borsària, PDA, PMP, cartells informatius / volants / tanques, al cotxe sistemes de navegació, etc) podria ser substituït pels dispositius virtuals que no costen res de produir, a part dels costos del desenvolupament del programari. Un exemple pot ser un rellotge de paret virtual, una llista de tasques pendents per al dia a prop del seu llit per mirar a primera hora del matí, etc.

~ 63 ~

5. Bibliografia 5.1. Esquemes i llistes de components Esquema del muntatge del nostre pla amb els leds infraroigs:

Hardware:

- 2 Piles d’1.5V

- Fullola de fusta

- Cables elèctrics FCC-68 Data cables

- Leds infraroigs SE3455/5455

- Porta piles (2 unitats d’1.5V)

- Potenciòmetre 100kΩ PIHER CP-21

- Switch 12000X778 series

- Wii remote

- Pen drive receptor bluetooth 2.0 EDR (Trust)

- PC (Windows XP)

~ 64 ~

- Projector (Benq W500)

Software:

- Python primer - Open GL

- Pygame

- PyWiiuse

- Numpy/scipy

- PyOpenGL

- Wiiuse

- SDL (simple direct layer)

5.2. Llistats de programes i llibreries El projecte no avarca aquests programes i arxius:

- Python v.2.5.2 (versions superiors a 2008 poden donar problemes a l’hora d’implementar wiiuse) - OpenGL 3.0 (Programa de dibuix 3D de python) - Pygame (Llibreries addicionals de python) - Numpy/Scipy - PyOpenGL - SDL (simple direct layer) - Pywiiuse - wiiuse

~ 65 ~

El projecte avarca aquests programes: - calibra_wii.py - wii.py - calibra_projector.py - Projector.py - Auxiliar.py - Punts.py - Principal.py

5.3. “Datasheets” dels components - Datasheet potenciòmetre PIHER CP-21: http://www.piher-nacesa.com/pdf/25-CP21v03.pdf - Datasheet switch APEM 12000X778 series: http://www.farnell.com/datasheets/3712.pdf - Datasheet IR leds SE3455/5455: http://sensing.honeywell.com/index.cfm?ci_id=140301&la_id=1&pr_id=131456 - Datasheet cables elèctrics, FCC-68: http://www.farnell.com/datasheets/84233.pdf

5.4. Documents i llibres d’interès - Shilpi Gupta and Christopher JaynesDepartment, Acitve Pursuit Tracking in a Projector-Camera System with Application to Augmente Reality. - Jamil Draréni, Sébastien Roy and Peter Sturm, Geometric Video Projector Auto-Calibration. DIRO, Université de Montréal, Canada and INRIA, Rhône-ALPES, France. - Simon Hay, Joseph Newman and Robert Harle, Optical Tracking Using Commodity Hardware. Digital technology group, Computer laboratory, University of Cambridge.

~ 66 ~

- Janne Heikkilä and Olli Silvén, A Four-step Camera Calibration Procedure with Implicit Image Correction. Infotech Oulu and Department of Electrical Engineering University of Oulu. - Johnny Chung Lee, Scott Hudson and Paul Dietz, Hydrid Infrared and Visible Light Projection for Location Tracking. Carnegie Mellon University and Mitsubishi Electric Research Labs.

- Jackie Neider, Tom Davis, Mason Woo, OpenGL Programming Guide. OpenGL

Architecture Review Board. Addison-Wesley Publishing Company. Copyright 1994 by Silicon Graphics, Inc.

5.5. Pàgines web d’interès - Programa Python: http://www.python.org/ - Open GL: http://www.opengl.org/ - Codis Font del Wiimote: http://wiiuse.net/ - Llibreries Pygame lliures: http://www.pygame.org/news.html - Informació codi font pyWiiuse: http://wwwx.cs.unc.edu/~gb/wp/blog/category/wiimote/ - Projectes Wii: http://www.johnnylee.net/projects/wii/ - Realitat Augmentada: http://es.wikipedia.org/wiki/Realidad_aumentada - Projecció planar: http://en.wikipedia.org/wiki/Planar_projection - Projecció ortogràfica: http://en.wikipedia.org/wiki/Planar_projection

~ 67 ~

- Rotació: http://en.wikipedia.org/wiki/Rotation_(mathematics) - Mapat de tall: http://en.wikipedia.org/wiki/Shear_mapping - Translació (geometria): http://en.wikipedia.org/wiki/Translation_(geometry) - Homografia: http://en.wikipedia.org/wiki/Homography - Geometri epipolar: http://en.wikipedia.org/wiki/Epipolar_geometry - Trianguació de la càmera: http://en.wikipedia.org/wiki/Camera_resectioning - Distància focal: http://en.wikipedia.org/wiki/Focal_length - Sensor format de imatge: http://en.wikipedia.org/wiki/Image_sensor_format - Puts cardinals (òptics): http://en.wikipedia.org/wiki/Cardinal_point_(optics) - Factor escalar: http://en.wikipedia.org/wiki/Scale_factor - Transformació directa lineal: http://en.wikipedia.org/wiki/Direct_linear_transformation