Acquisizione dei segnali e Estrazione di Feature

Come gi`a sottolineato durante lo studio di fattibilit`a (sez 5.1.1), uno dei problemi pi`u grandi sorti durante la progettazione di questo framework, risiede essenzialmente nella definizione di una mappatura Kinect SDK → Java. L’unica libreria capace di fornire una mappatura di questo tipo `e J4K1 [20].

Libreria J4K

La libreria J4K `e una famosa libreria Java open source che implementa un binding Java per l’SDK Kinect di Microsoft. Comunica con una libreria na- tiva di Windows, che gestisce i flussi di profondit`a, colore, infrarossi e scheletro di Kinect utilizzando la JNI (Java Native Interface).

Compatibilit`a La libreria J4K `e compatibile con tutti i dispositivi kinect (Kinect per Windows, Kinect per XBOX, Kinect o Kinect 2) e consente di con- trollare pi`u sensori di qualsiasi tipo da una singola applicazione, a condizione

1_{Allo stato dell’arte, sono presenti varie API in linguaggio Java interfacciate con Kinect;}

purtroppo per`o, la maggior parte di esse non consente una gestione globale e semplificata del dispositivo.

che le capacit`a del sistema lo consentano. Ad esempio, `e possibile controllare due sensori Kinect v1 o uno Kinect v1 e uno Kinect v2 collegati tramite USB 3.0 allo stesso computer. Inoltre, la libreria J4K contiene diverse comode clas- si Java che convertono i frame di profondit`a, i frame di scheletro e i frame di colore ricevuti da un sensore Kinect in oggetti Java di facile utilizzo.

Estensioni Facoltativamente, `e possibile utilizzare la libreria Java JOGL (JogAmp) per visualizzare, tramite OpenGL, i dati Kinect come superfici 3D [21]. L’uso della libreria JOGL `e facoltativo e non `e necessario se non si utilizzano i metodi di disegno forniti nelle classi Java J4K.

Questa (fig 5.7) `e una schermata della finestra di dialogo Kinect Viewer, che `e inclusa nella libreria Java di J4K e offre un modo semplice per visualizzare i dati correnti e una semplice interfaccia grafica per la modifica dei parametri del sensore.

Figura 5.7: Il pannello di controllo per Kinect fornito dalla libreria J4K

Come scrivere un programma Kinect-Java con J4K Tralasciando per un attimo le funzionalit`a mappate da J4K, concentriamoci sullo studio della struttura di un programma Kinect.

Il codice qua sotto mostra un esempio canonico di programma Kinect-Java. import edu.ufl.digitalworlds.j4k.J4KSDK;

import edu.ufl.digitalworlds.j4k.DepthMap; import edu.ufl.digitalworlds.j4k.Skeleton; import edu.ufl.digitalworlds.j4k.VideoFrame; public class Kinect extends J4KSDK{

VideoFrame videoTexture; public Kinect() {

super(); }

@Override

public void onDepthFrameEvent(short[] depth_frame, byte[] player_index, float[] XYZ, float[] UV) {

DepthMap map=new

DepthMap(getDepthWidth(),getDepthHeight(),XYZ); }

@Override

public void onSkeletonFrameEvent(boolean[] skeleton_tracked, float[] joint_position, float[] joint_orientation, byte[] joint_status) {

Skeleton skeletons[] = new

Skeleton[getMaxNumberOfSkeletons()];

for(int i = 0; i < getMaxNumberOfSkeletons(); i++) {

skeletons[i] = Skeleton.getSkeleton(i, skeleton_tracked, joint_position, joint_orientation, joint_status, this); }

}

@Override

public void onColorFrameEvent(byte[] data) {

videoTexture.update(getColorWidth(), getColorHeight(), data); }

}

Listato 5: La struttura di un semplice programma Kinect-Java

Come vediamo l’implementazione `e molto semplice. La parte pi`u importante del codice in tutti gli esempi forniti `e la definizione di una classe Java che ge- stisce i flussi live ricevuti da un sensore Kinect. `E possibile definire facilmente tale classe anche in meno di 10 righe di codice java. La definizione di una classe Kinect-Java avviene in 2 semplici passaggi:

• Prima di tutto, la classe dovrebbe estendere la classe J4KSDK dalla libreria J4K, come mostrato sopra. Facoltativamente, puoi definire il tuo costruttore e i parametri personalizzati per la tua classe, come mostrato nell’esempio seguente.

• Infine, bisogna implementare l’interfaccia dei 3 metodi FrameEvent. Questi metodi sono fondamentali poich`e verranno automaticamente chia- mati ogni volta che viene ricevuto un nuovo frame di profondit`a, video

o scheletro dal sensore Kinect. `E possibile personalizzare il contenuto di questi 3 metodi in base alle esigenze della propria applicazione.

Funzionalit`a offerte: J4K oltre a definire 3 metodi dedicati alla gestio- ne degli stream, garantisce anche un buona gestione lato sensore. La classe J4KSDK in particolare effettua un binding per il controllo totale di Kinect, definendo una quanitit`a impressionante di funzionalit`a. Tramite questa classe possiamo controllare l’angolo di elevazione di Kinect, impostare la modalit`a “Seated” e addirittura acquisire un flusso di dati provenienti dall’accelerome- tro.

Integrazione di J4K lato Framework

L’integrazione di J4K con il nostro framework avviene in modo molto sem- plice ed intuitivo. Data la natura modulare dei Sensori `e possibile disaccoppia- re totalmente le funzionalit`a offerte dalla libreria da quelle del framework. In particolare al fine di nascondere aspetti implementativi a basso livello `e stato fatto uso del Pattern Adapter.

La classe che implementer`a J4KSDK sar`a dunque un Kinect adapter, il quale agir`a da filtro ed elaboratore di segnali.

public void onSkeletonFrameEvent(final boolean[] skeletonTracked, final float[]

jointPosition, final float[] jointOrientation, final byte[] jointStatus) {

Skeleton skeleton;

for (int i = 0; i < this.getMaxNumberOfSkeletons(); i++) { if (skeletonTracked[i] && this.first) {

this.first = false;

skeleton = Skeleton.getSkeleton(i, skeletonTracked, jointPosition,

jointOrientation, jointStatus, this); Vector2D joint1;

Vector2D joint2;

joint1 = new Vector2D(

(int) (skeleton.get3DJoint(Skeleton.HAND_RIGHT)[0] * KinectAdapter.MULTIPLIER),

(int) (skeleton.get3DJoint(Skeleton.HAND_RIGHT)[1] * KinectAdapter.MULTIPLIER));

joint2 = new Vector2D((int)

(skeleton.get3DJoint(Skeleton.HAND_LEFT)[0] * KinectAdapter.MULTIPLIER),

* KinectAdapter.MULTIPLIER)); this.kinect.notifyOnSkeletonChange(joint1, joint2); } } this.first = true; } @Override

public void attacheKinect(final KinectObserver kinect) { this.kinect = kinect;

}

Listato 6: La struttura di un semplice programma Kinect-Java

Come vediamo nel listato 6, l’elaborazione avviene in modo abbastanza sem- plice:

1. Identificazione e Estrazione Skeleton: Viene costruito un oggetto di tipo Skeleton e inizializzato con i valori dell’utente tracciato. Per fare ci`o si ciclano tutti gli skeleton presenti e si considera solamente il primo tracciato.

2. Creazione dei vettori-giuntura: Ottenuto lo Skeleton riguardante l’uten- te, si inizializzano i due vettori 2D riguardanti le due giunture richieste, in questo caso Mano Sinistra e Mano Destra.

3. Notifica dei vettori: I vettori vengono notificati attraverso una catena di Observer alla classe Tracker passando per la classe Kinect.

Conversione 3D → 2D L’algoritmo appena definito effettua anche una ri- duzione di dimensionalit`a sui vettori processati. Nel nostro caso la riduzione `e avvenuta semplicemente ignorando la terza dimensione. Questa operazione potrebbe in alcuni casi generare problemi, infatti, non effettuando una nor- malizzazione rispetto alla profondit`a `e possibile che il riconoscitore riscontri difficolt`a nel classificare gesture avvenute a una distanza diversa da quella di registrazione. In altri termini, se registrassimo la gesture “Cerchio” a una di- stanza di 50 centimetri e poi la andassimo a riconoscere a una distanza di 2 metri, la prospettiva indurrebbe un cambio di scala nei valori ottenuti falsando cosi tutto il processo.