Notice: Now on HTTPS. Report any rough edges to marcan@marcan.st

Getting Started/it

From OpenKinect
Jump to: navigation, search
Lingua: English  • français • italiano • português do Brasil

Prima di iniziare

Questa pagina spiega come iniziare a usare OpenKinect. Le librerie sono molto in divenire, e questo non sarà il procedimento definitivo. Ciò significa che anche queste istruzioni potrebbero non essere aggiornate rispetto agli ultimi commit. Potete dare un'occhiata ai seguenti link per ulteriori informazioni:

  • il file README del progetto github (e i file README nel resto del project tree per i componenti specifici)
  • la sezione Wrapper
  • la mailing list OpenKinect
  • le FAQ

Supporto

Per richieste di supporto nel canale irc OpenKinect o nella mailing list specificate la piattaforma in uso, la versione del software che si sta cercando di compilare o installare e le informazioni sul contesto come spiegato qui.

L'adattatore

Il Kinect ha bisogno di una propria fonte di alimentazione, indipendente dalla connessione USB che è necessaria per lavorare su un computer. L'ultima Xbox360 può alimentare il Kinect direttamente, ma la vecchia Xbox richiede un adattatore per tale scopo. Pertanto, il Kinect che è in bundle con la Xbox360 non include un adattatore, mentre il Kinect che è venduto separatamente sì. L'adattatore viene venduto qui. Questo adattatore è necessario per utilizzare l'hardware Kinect sul tuo computer con libfreenect.

Fakenect

È inoltre possibile utilizzare l'utility Fakenect, un simulatore di libfreenect/interfaccia fittizia, per eseguire le demo senza avere un Kinect.

Grazie!

Linux

Pacchetti binari

Pacchetti rpm e deb già compilati sono disponibili qui: http://livingplace.informatik.haw-hamburg.de/blog/?p=228

Notate che non sono presenti dispositivi udev al momento, per cui è necessario eseguire i propri programmi come root (usando sudo) o inserire le regole udev necessarie manualmente (vedi #Utilizzo come utente normale).

Questi pacchetti sono aggiornati al 19 novembre 2010.

Ubuntu

Un ppa launchpad per Ubuntu Lucid (10,04) e Maverick (10.10) è disponibile all'indirizzo:

https://launchpad.net/~-ArneAlamut/+archive/freenect

Per usarlo, aprite una console ed eseguite:

$ sudo add-apt-repository ppa:arne-alamut/freenect

Risincronizzate l'elenco dei pacchetti dalle repository:

$ sudo apt-get update

Dopo di che usate:

$ sudo apt-get install freenect

Verranno installati i pacchetti libfreenect0.0, libfreenect-demo e libfreenect-dev.

Dopo di che, è necessario aggiungere se stessi al gruppo 'video' ed effettuare nuovamente il login. Il pacchetto include già le regole necessarie per udev in modo che l'accesso al dispositivo sia possibile per gli utenti nel gruppo 'video'.

$ sudo adduser TUONOME video

Ricordatevi di effettuare il logout e nuovamente il login. Non è necessario riavviare il sistema, potete collegare il Kinect da subito (se era già collegato, scollegatelo e ricollegatelo).

Per avviare le applicazioni demo:

$ freenect-glview

Tutte le applicazioni demo iniziano con il prefisso freenect- .

Installazione manuale su Ubuntu

Istruzioni copia-incolla rapide:

sudo apt-get install git-core cmake libglut3-dev pkg-config build-essential libxmu-dev libxi-dev libusb-1.0-0-dev
git clone https://github.com/OpenKinect/libfreenect.git
cd libfreenect
mkdir build
cd build
cmake ..
make
sudo make install
sudo ldconfig /usr/local/lib64/
sudo glview

Questo dovrebbe essere uno dei modi più veloci per far funzionare il Kinect su Ubuntu. Questo ulteriore passaggio è naturalmente consigliato:

sudo adduser YOURNAME video
cat << EOF >> /etc/udev/rules.d/51-kinect.rules
# ATTR{product}=="Xbox NUI Motor"
SUBSYSTEM=="usb", ATTR{idVendor}=="045e", ATTR{idProduct}=="02b0", MODE="0666"
# ATTR{product}=="Xbox NUI Audio"
SUBSYSTEM=="usb", ATTR{idVendor}=="045e", ATTR{idProduct}=="02ad", MODE="0666"
# ATTR{product}=="Xbox NUI Camera"
SUBSYSTEM=="usb", ATTR{idVendor}=="045e", ATTR{idProduct}=="02ae", MODE="0666"
EOF

Compilazione manuale sotto Linux

Queste istruzioni hanno bisogno di più lavoro, per lo più sono tratte da README.asciidoc

Installare le dipendenze

Per la compilazione, è necessario avere i seguenti programmi/librerie installati:

* cmake
* libusb-1.0-0
* libusb-1.0-0-dev
* pkg-config
* libglut3
* libglut3-dev

Notate che i nomi dei pacchetti elencati orientati verso Ubuntu/Debian. Per una installazione su RedHat/Fedora usando yum/rpms, il seguente comando dovrebbe installare tutti i pacchetti necessari per recuperare, compilare ed eseguire la demo glview:

$ yum install git cmake gcc gcc-c++ libusb1 libusb1-devel libXi libXi-devel libXmu libXmu-devel freeglut freeglut-devel

Per chi usa APT: (funziona su Ubuntu 10.10)

$ sudo apt-get install cmake libglut3-dev pkg-config build-essential libxmu-dev libxi-dev libusb-1.0-0-dev

Clonare la repository

$ git clone https://github.com/OpenKinect/libfreenect.git
$ cd libfreenect

Eseguire cmake e compilare

$ mkdir build
$ cd build
$ cmake ..
$ make
$ sudo make install
$ sudo ldconfig /usr/local/lib64/

Errori

Se ottenete il seguente errore cmake:

$ CMake Error: The following variables are used in this project, but they are set to NOTFOUND.
$ Please set them or make sure they are set and tested correctly in the CMake files:
$ GLUT_Xi_LIBRARY (ADVANCED)
$    linked by target "glview" in directory /home/user/libfreenect/examples
$ GLUT_Xmu_LIBRARY (ADVANCED)
$    linked by target "glview" in directory /home/user/libfreenect/e

avete bisogno di installare libxi-dev e libxmu-dev/libxmu-headers. Se state utilizzando Ubuntu 10.04, digitate il comando:

$ sudo apt-get install libusb-1.0-0-dev libxmu-dev libxi-dev

Nel caso in cui glview dia un errore di libreria condivisa:

$ glview
glview: error while loading shared libraries: libfreenect.so.0.0: cannot open shared object file: No such file or directory

È necessario aggiornare la cache ldconfig:

$ sudo ldconfig /usr/local/lib64/

(il path dipende, naturalmente, da dove sono state installate le librerie condivise).

Python

Per compilare il wrapper Python avete bisogno del pacchetto "python-dev" e cython. Il pacchetto cython incluso in Ubuntu 10.10 sembra essere non funzionante (vedi qui), scaricate la versione disponibile qui o provate

$ sudo easy_install cython

Per ulteriori informazioni sui wrapper Python vedere questa pagina [1].

Utilizzo come utente normale

Per poter accedere al Kinect avete bisogno di aggiungere se stessi al gruppo video e modificare le autorizzazioni per il dispositivo creato:

create il file: /etc/udev/rules.d/66-kinect.rules

#Rules for Kinect ####################################################
SYSFS{idVendor}=="045e", SYSFS{idProduct}=="02ae", MODE="0660",GROUP="video"
SYSFS{idVendor}=="045e", SYSFS{idProduct}=="02ad", MODE="0660",GROUP="video"
SYSFS{idVendor}=="045e", SYSFS{idProduct}=="02b0", MODE="0660",GROUP="video"
### END #############################################################

e aggiungete il vostro utente al gruppo video:

$ sudo adduser TUONOME video

Test del Kinect

Se non avete eseguito i passi nella sezione #Utilizzo come utente normale, dovete eseguire il comando come root:

$ bin/glview

oppure

$ sudo bin/glview

OS X

Si consiglia di installare (almeno i prerequisiti) tramite un gestore di pacchetti. Se non utilizzate già macports o fink, provate Homebrew, dal momento che vi è un pacchetto completo creato per esso.

MacPorts

Le versioni correnti di MacPorts devono supportare le varie versioni di libusb. Abbiamo aggiunto un port speciale libusb-devel che compila la libreria libusb modificata richieste dal Kinect.

Dopo aver installato MacPorts, eseguire i comandi:

 sudo port install git-core
 sudo port install libtool
 sudo port install libusb-devel

Poi spostatevi in una directory di lavoro ed eseguite:

git clone https://github.com/OpenKinect/libfreenect.git

e proseguire come nella sezione #Build manuale sotto OSX. La versione di libusb trovata da cmake sarà corretto e già modificata, semplificando notevolmente il processo di generazione!

Fink

Dopo aver installato Fink, eseguite i comandi seguenti. In primo luogo, configurate Fink per compilare i pacchetti dal repository unstable, in modo da poter ottenere l'ultima versione di libusb:

 fink configure 

Quindi installate le dipendenze freenect:

 fink install cmake git libusb1

Poi muovetevi in una directory di lavoro ed eseguite:

git clone https://github.com/OpenKinect/libfreenect.git

e proseguire come nella sezione #Build manuale sotto OSX.

Homebrew

Se non avete già Homebrew, è abbastanza semplice installarlo.

Nota: anche se avete già homebrew, assicuratevi di aggiornare le formule (eseguite `brew update`), prima di tentare di installare libfreenect, in quanto sono stati eseguiti numerosi bugfix di cmake recentemente.

Ottenere le formule

Dal momento che il progetto è ancora molto soggetto a modifiche, i pacchetti non sono ancora nella directory homebrew ufficiale, quindi sarà necessario scaricarli manualmente:

cd /usr/local/Library/Formula
curl --insecure -O "https://github.com/OpenKinect/libfreenect/raw/master/platform/osx/homebrew/libfreenect.rb"
curl --insecure -O "https://github.com/OpenKinect/libfreenect/raw/master/platform/osx/homebrew/libusb-freenect.rb"

Installazione

brew install libfreenect

Ed ecco fatto,avete finito! Una copia della demo glview ora dovrebbe essere nel PATH, così potete eseguire semplicemente:

glview

per confermare che tutto abbia funzionato bene.

Build manuale sotto OSX

Prerequisiti:

Clonate le repository OpenKinect e Github:

git clone https://github.com/OpenKinect/libfreenect.git
git clone git://git.libusb.org/libusb.git

Non avete bisogno di recuperare la patch per libusb se avete già installato libusb-devel tramite MacPorts (vedi sopra)! Al contrario, se clonate libusb da github sarà necessario applicare la patch per OpenKinect in questo modo:

cd libusb
./autogen.sh
patch -p1 < ../libfreenect/platform/osx/libusb-osx-kinect.diff
./configure LDFLAGS='-framework IOKit -framework CoreFoundation'
make
sudo make install

Configurate quindi OpenKinect:

cd ../libfreenect/
mkdir build
cd build
ccmake ..

Non preoccupatevi se viene mostrato il messaggio 'Empty cache' all'avvio. Adesso premete 'c' in ccmake per configurarlo. Se avete installato libusb via MacPorts o Homebrew, funzionerà senza ulteriori modifiche. In caso contrario, è probabile un esito negativo, perché libusb non verrà trovata. Premete 'e' per uscire dall'help e modificate manualmente il path libusb nella schermata successiva, in modo che punti a /usr/local/include/libusb-1.0/ e continuaee.

Quando avete finito, compilate OpenKinect:

cmake ..
make

Se volete compilare OpenKinect come un progetto Xcode, invece eseguite:

cmake -G Xcode ..
make

Avete finito! Ora dovrebbe esserci un programma chiamato 'glview' in libfreenect/build/bin. Collegate il vostro Kinect e avviatelo! Se ottenete il messaggio 'ld: warning: in /usr/local/lib/libusb-1.0.dylib, missing required architecture x86_64' quando eseguite make, dovete correggere i percorsi di cmake: devono puntare a /opt ... se libusb è stato installato tramite MacPorts.

Per avere i file disponibili a livello globale sul vostro Mac eutilizzarli con i vostri progetti, li potete installare:

sudo make install

Utilizzo in parallelo con pyusb

Se volete utilizzare pyusb per giocare con il Kinect, avete bisogno di libusb-1.0.8 (sembra). Installatelo tramite homebrew e definite la variabile _lib prima di trovare il dispositivo USB:

from ctypes import *
import usb.core
import usb.utils

_lib = CDLL('/usr/local/Cellar/libusb/1.0.8/lib/libusb-1.0.dylib') # Questo è il path dove homebrew inserisce le librerie libusb
dev = usb.core.find(idVendor=0x045e, idProduct=0x02B0)

Windows

Se siete alla ricerca di una panoramica delle caratteristiche del progetto prima della compilazione, è possibile dare un'occhiata a questa demo precompilata (è disponibile anche il sorgente) che utilizza libfreenect e OpenCV.

Compilazione manuale dai sorgenti

Introduzione

Compilare dai sorgenti non dovrebbe richiedere alcuna esperienza specifica, ma può essere complicato per alcuni. Questa introduzione servirà a dare a coloro che ne hanno bisogno un po' di background su ciò che stiamo cercando di fare qui. Per riassumere, dovrete scaricare gli ultimi sorgenti libfreenect e le dipendenze separate. Le dipendenze verranno utilizzate in due modi. In primo luogo, dovete copiare i file .dll sul vostro sistema, in una posizione accessibile alle applicazioni. In secondo dovete collegare i file header e .lib al codice sorgente utilizzando il programma cmake-gui, in modo da configurare il progetto e generare i makefile necessari per la compilazione. Infine, potrete aprire il progetto configurato sul vostro ambiente di sviluppo (es. Visual Studio 2010) per la compilazione o per cominciare il vostro sviluppo. I file DLL sono necessari in quanto le demo hanno bisogno di determinate librerie per funzionare (come qualsiasi altra applicazione). I file header e .lib sono invece necessari per una corretta compilazione del progetto. Notate che la libfreenect compilata è di per sé una libreria DLL, di cui il computer avrà bisogno per eseguire, ad esempio, la demo glview.exe. Tutto questo dovrebbe diventare abbastanza chiaro man mano che eseguite i vari passi.

Ottenere i file sorgenti

Ci sono due modi per ottenere gli ultimi sorgenti:

  1. Andate al progetto github OpenKinect, selezionare il branch desiderato (master o unstable per esempio - vedi sotto) e cliccate sul pulsante "Download", quindi estraete i file in una posizione conveniente, oppure
  2. Usate Git per creare e mantenere una cartella del progetto aggiornata ed accedere a qualsiasi branch a livello locale.

Utilizzo di Git

  • Scaricate e installate Git con queste impostazioni:
    • Accettare la licenza, ecc.
    • Scegliete il livello di integrazione con la shell desiderato
    • Scegliete "Run git from the Windows Command prompt"
    • Scegliete "Check out Windows style, commit Unix-style line endings"
  • Aprite un prompt dei comandi, muovetevi nella posizione in cui desiderate che sia la cartella di origine (/libfreenect) digitate:
$ git clone https://github.com/OpenKinect/libfreenect.git //scarica il progetto, crea il branch master locale
$ cd libfreenect                                            //cd nella directory dei sorgenti
$ git branch --track unstable origin/unstable        //crea il branch locale unstable da quello remoto
$ git checkout master                                //esegue il checkout del branch master (o unstable)
$ or
$ git checkout unstable
$ git pull                                           //aggiorna il contenuto del branch selezionato
  • Il contenuto della cartella libfreenect cambierà interattivamente quando eseguirete il checkout di un branch specifico, così non avrete bisogno di cercare la cartella di un branch specifico all'interno della directory libfreenect. Eseguite il checkout del branch che desiderate configurare e procedete utilizzando la cartella libfreenect come sorgente di cmake. Questa configurazione consente di passare facilmente tra il i branch master e unstable, aggiornare i file sorgenti e quindi configurare il branch si vuole costruire.
  • Il comando "git branch" vi mostrerà i diversi branch (in questo caso master e unstable) e quale è attualmente selezionato. È inoltre possibile visualizzare i log di sviluppo per il branch su cui lavorate con il comando "git log" (usate Shift + Q per uscire dal log).

Master vs unstable

Se avete intenzione di modificare libfreenect, scrivendo wrapper, o cercando gli ultimi sviluppi potreste voler eseguire il checkout del branch 'unstable'. unstable contiene le ultime modifiche che non sono state ancora completamente testate. Altrimenti provate il branch 'master'.

  • Prendere atto che i rami master e unstable sono stati sincronizzati il 6 gennaio 2011; leggete questo update per ulteriori informazioni.
  • Il 15 febbraio, il supporto per molteplici risoluzioni è stato aggiunto al branch unstable e le modalità 1280x1024 RGB e IR sono state abilitate, come spiegato qui.

Dopo aver ottenuto il file sorgenti, è necessario scaricare le dipendenze necessarie per configurare e costruire la libreria e quindi installare il driver hardware.

Dipendenze

Per ogni dipendenza richiesta, prima scaricate e installate le librerie (.dll) sul vostro sistema e quindi individuare i percorsi per le librerie (.lib o .a) e i file header (.h) di cui avrete bisogno in seguito per configurare il progetto progetto con cmake:

Dipendenza Installazione Libreria/header da usare con cmake (vedere questa PrintScreen)
libusb-win32 - scaricare ed estrarre le ultime libusb-win32-bin-x.x.x.x.zip Vedere sezione successiva (installazione driver) Le cartelle /lib e /include contengono le librerie e i file header necessari per configurare il progetto; a seconda del compilatore scelto, potrebbe essere necessario specificare un file di libreria diverso:
  • Per esempio, come percorso della libreria libusb in cmake (LIBUSB_1_LIBRARY) usate /lib/msvc/libusb.lib per MS Visual Studio 2010, o /lib/gcc/libusb.a se prevedete di utilizzare MinGW
  • Selezionare il percorso della cartella /include come percorso di inclusione in cmake (LIBUSB_1_INCLUDE_DIR)

Per maggiori informazioni leggete il readme libusb-win32 e la loro wiki

pthreads-win32 - Scaricare ed estrarre le ultime pthreads-w32-x-x-x-release.exe Trovate la cartella /lib e copiate la libreria DLL appropriata in /windows o /windows/system32 (vedi Librerie/header a destra per capire quale usare) Le cartelle /lib e /include contengono le librerie e i file header necessari per configurare il progetto; a seconda del compilatore che si sceglie, è necessario specificare un file di libreria diverso:
  • Per esempio, come percorso della libreria pthread in cmake (THREADS_PTHREADS_WIN32_LIBRARY) utilizzare /lib/pthreadVC2.lib per MS Visual Studio 2010, mentre se prevedete di utilizzare MinGW usate /lib/pthreadGC2.a
  • In entrambi i casi sarà necessario installare il file dll corrispondente (phtreadVC2.dll o pthreadGC2.dll) in /windows/system32
  • Selezionare il percorso della cartella pthread/include come percorso di inclusione in cmake (THREADS_PTHREADS_INCLUDE_DIR)

Per maggiori informazioni visita il pthreads-win32 readme e le loro FAQ

Glut - Scaricare ed estrarre le ultime GLUT-x.x.x-bin.zip Trovate il file glut32.dll e copiatelo in /windows o qualsiasi directory inclusa nella variabile PATH di sistema (vedi questa spiegazione)
  • Con MSVC, è necessario copiare il file di intestazione per glut.h nella sottocartella /include/GL e la libreria glut32.lib nella sottocartella /lib della vostra directory VC (per esempio /Programmi/Microsoft Visual Studio 10.0/VC/) - se la cartella GL non c'è, createla e mettete il file glut.h lì.
  • In cmake-gui, inserite il percorso per l'header fino alla cartella /include cartella (NON /include/GL) e il percorso della libreria stessa (/lib/glut32.lib) nei percorsi cmake (GLUT_INCLUDE_DIR e GLUT_glut_LIBRARY rispettivamente)

Per maggiori informazioni leggete il readme di GLUT

Installazione del driver

Ci sono due parti di libfreenect - il driver di basso livello basato su libusb e libfreenect stessa, la libreria che comunica con il driver. Dovete installare il driver solo una volta.

Windows 7: step-by-step walkthrough (dovrebbe funzionare anche con Windows XP!)

  • Collegate il Kinect. Windows avviserà che nessun driver di periferica è stato trovato per il dispositivo collegato (il led del Kinect non si accende). Se Windows presenta una finestra di dialogo per la ricerca di driver, è sufficiente chiuderla.
  • Aprite Gestione periferiche: Start >> Pannello di controllo >> Sistema e sicurezza>> Sistema>> Gestione dispositivi
  • Un dispositivo chiamato "Xbox NUI Motor" dovrebbe essere presente da qualche parte (probabilmente sotto "Altre periferiche") con un piccolo simbolo di avvertimento giallo"!" sopra la sua icona. Fate clic con il tasto destro su di essa e selezionate "Aggiornamento software driver", quindi cliccate su "Cerca il software del driver nel computer".
  • Cliccate "Sfoglia" e selezionare la cartella in cui si trova il file "XBox_NUI_Motor.inf" (/platform/windows/inf all'interno della cartella sorgente libfreenect). Andate avanti e, se avvertiti da Windows che un driver non certificato sta per essere installato, indicate di installarlo comunque.
  • Dopo di che, il LED del Kinect dovrebbe iniziare a lampeggiare verde. Ora ci saranno due ulteriori dispositivi nella lista Device Manager: "Xbox NUI Camera" e "Xbox NUI Audio". Ripetere le istruzioni di cui sopra anche per loro.

Ora siete pronti per configurare libfreenect prima di compilare.

Configurazione con cmake-gui

Windows cmakegui.png

Seguire questa procedura per configurare libfreenect per la compilazione:

  1. Scaricate CMake (Cross-Platform Make) e assicuratevi di avere un compilatore C funzionante (Visual Studio 2010 o MinGW)
  2. Lanciate cmake-GUI e selezionare la cartella /libfreenect come origine, selezionare una cartella di output, selezionare le caselle "Avanzate" e "Raggruppa" per visualizzare più variabili e categorizzare e quindi fare clic su "Configura"
  3. Selezionare il compilatore C che si desidera utilizzare
  4. Selezionare le opzioni desiderate, prendendo in considerazione quanto segue:
    1. Per ora selezionate solo le opzioni EXAMPLES e C_SYNC in BUILD. Le altre opzioni di generazione come FAKENECT non sono state ancora aggiornate per Visual Studio
    2. Date un'occhiata alla seguente nota se siete interessati nella compilazione del wrapper PYTHON
  5. Dipendenze irrisolte verranno visualizzate in rosso nella GUI CMake. Fornite i percorsi delle dipendenze mancanti seguendo queste linee guida, e fare clic su "Configura" nuovamente:
    1. Le variabili *_LIBRARY devono puntare ad un vero e proprio file .lib, non ad una cartella
    2. Le variabili INCLUDE devono puntare alla cartella di inclusione appropriata
  6. Quando tutti gli errori sono stati risolti, fate clic sul pulsante "Generate" per creare il Makefile per il compilatore.

Compilazione e installazione

Ora che il progetto è configurato, aprite libfreenect.sln dalla cartella di output e compilate con Visual Studio. Poi cercare i file compilati in /bin e /lib

  • Le librerie freenect in /lib sono state compilate ma non ancora installate. Per utilizzarle è necessario:
    • Aggiungere il percorso della cartella /lib alla variabile d'ambiente PATH o
    • Copiare le librerie in una cartella già nel percorso di sistema come /windows/system32 o
    • Copiare le librerie nella cartella del programma che si desidera eseguire
  • Se alcuni elementi non vengono compilati la prima volta, è sufficiente fare clic con il tasto destro sulla soluzione e selezionare "Build" o "Rebuild" per vedere se gli elementi mancanti vengono compilati
  • In caso di problemi controllare il readme nella cartella /libfreenect/platform/windows per ulteriori informazioni.

Test

Per fare un veloce test eseguite /bin/glview.exe

  • È anche una buona idea controllare la sezione Wrapper e la mailing list per ulteriori idee e soluzioni...