Universitatea Politehnică Bucureşti

Facultatea de Automatică şi Calculatoare

Departamentul de Automatică şi Ingineria Sistemelor

LUCRARE DE LICENŢĂ
Sistem de recunoaștere și interpretare a gesturilor
bazat pe Microsoft Kinect

Absolvent
Pisică Andrei

Coordonator
SL dr.ing. Florin ANTON

Bucureşti, 2016
Cuprins

1.Introducere ........................................................................................................................................ 4
2. Sistemul Microsoft Kinect ............................................................................................................. 6
2.1 Modelul geometric Kinect ....................................................................................................... 9
2.2 Posibile cauze ale achiziționării datelor eronat................................................................. 11
2.3 Rezoluția imaginii de adâncime și densitatea punctelor de lumină IR ........................ 11
2.4 Identificarea punctelor luminoase ce formează articulaţii ............................................. 11
2.5 Algoritmul Mean-Shift .......................................................................................................... 13
3. Detecția și recunoașterea gesturilor........................................................................................... 16
3.1 Pregătirea datelor necesare .................................................................................................... 16
3.2 Recunoașterea statică sau a pozițiilor ................................................................................. 17
3.3 Programarea sistemului să fie invariant la rotația corpului față de Kinect ................. 21
3.4 Recunoașterea dinamică sau a gesturilor ........................................................................... 21
3.4.1 Recunoașterea dinamică folosind algoritmul Dynamic Time Warping ................ 22
3.4.1.2 Recunoașterea dinamică aplicată ............................................................................... 25
3.4.2 Recunoașterea dinamică folosind algoritmul de recunoaștere a gesturilor statice
....................................................................................................................................................... 26
4.Structura și funcțiile sistemului .................................................................................................. 28
4.1 Modurile de funcționare ........................................................................................................ 29
4.2 Stocarea datelor ....................................................................................................................... 30
4.3 Interfața modurilor de funcționare ...................................................................................... 31
4.4 Analiza similaritudinii între două poziții .......................................................................... 33
5.Integrarea sistemului în diverse aplicații .................................................................................. 36
6.Rezultate experimentale și concluzii .......................................................................................... 39
6.1 Rezultate experimentale ........................................................................................................ 39
6.2 Planuri de viitor....................................................................................................................... 43
6.3 Concluzii ................................................................................................................................... 44
Bibliografie ........................................................................................................................................... 45

3
1.Introducere

Conform studiilor de recensământ din Uniunea Europeana din ultimii 14 ani,

se poate constata o creștere liniară a numărului de persoane ce depășesc vârsta de 45-
50 de ani.[1] Odată cu înaintarea în vârsta, riscurile de a suferi un accident vascular
cerebral cresc semnificativ. Totodată, un ritm de viață neechilibrat, alături de un mediu
de lucru stresant pot duce la accidente vasculare chiar și în rândul persoanelor tinere.
Durata de recuperare depinde de intensitatea accidentului vascular cerebral cât și de
des sunt efectuate exerciții de recuperare fizioterapeutice. Așadar pacientul, în cazul
în care suferă un accident vascular ușor, este supus efectuării unor exerciții fizice ce
au ca scop reabilitarea și recăpătarea mobilității pacientului. În foarte multe situații
deplasarea unei persoane cu dificultăți de mișcare este dificilă și asistată de o altă
persoană până la sala de exerciții fizioterapeutice, respectiv înapoi acasă.

Scopul lucrării este de a oferi o alternativă bolnavilor care stau în zone rurale
sau greu accesibile și nu au în zonă un centru de recuperare. De altfel acest sistem
poate fi utilizat de toți pacienții care doresc executarea exercițiilor din comfortul casei.

Microsoft a achiziționat în anul 2010, un senzor de distanță capabil să identifice

poziția fiecărei încheieturi a unei persoane ce se află îndreptată în spre direcția
acestuia. Senzorul a fost patentat inițial de firma PrimeSense iar Microsoft a cumpărat
drepturile de patentare sub denumirea de Microsoft Kinect.

Exercițiile de fizioterapie asistată cu ajutorul unui senzor Microsoft Kinect au

fost abordate în diferite lucrări de specialitate. În lucrarea [2] autorul prezintă
avantajele utilizării unui asemenea sistem de monitorizare medicală. Un avantaj
menționat, este acela de a îi oferi pacientului posibilitatea de a își programa orele de
exercițiu după bunul plac. Deasemenea folosirea unui astfel de sistem oferă costuri
scăzute, suportate de către pacient. Folosind acest senzor pe post de supervizor în
efectuarea exercițiilor diminuează riscurile de accidentare din cauza executării
incorecte a anumitor mișcări, acest lucru fiind un alt avantaj major prezentat în
lucrearea [2]. În timp, utilitatea acestui dispozitiv a depășit așteptările celor de la
Microsoft, fiind utilizat în educarea copiilor ce suferă de autism cât și în sala de
operație a medicilor. În cartea [3] se prezintă folosirea roboților pe post de ajutor
personal ca fiind tot mai des întalnită în zilele noastre. De la roboți ce ajută persoanele
imobilizate să se deplaseze, pâna la roboți ce sunt concepuți a fi folosiți pe post de
logoped, cartea prezintă Kinect-ul drept un ajutor medical personal ce poate fi folosit
chiar și în urma unei accidentări mai severe provenite din pricina unui accident de
muncă, sau datorită unor factori externi, pierzând astfel mobilitatea normală a unui
membru.

4
 În lucrarea [5] se prezintă o altă utilitate a Kinect-ului decât pe plan medical. Se
prezintă o metodă nouă de control a dispozitivelor inteligente, și anume utilizarea
gesturilor în obținerea comportamentului dorit fară a fi nevoie de o interacțiune fizică,
sau folosind modul convențional cu telecomandă. Pâna în prezent voice-recognition a
fost cel mai folosit mod de Human-Computer Interaction dezvoltat și implementat în
diferite sisteme, iar de curând, s-a implementat recunoașterea de gesturi sau poziții.

Așadar se pot observa avantajele acestui dispozitiv folosit pe plan medical dar
nu numai. Pentru a putea încuviința supervizarea unui dispozitiv electric în exercițiile
fizice, sistemul Kinect-Computer prezentat în această lucrare trebuie învățat să
respecte anumite condiții impuse. Așa cum se prezintă și în lucrarea [6], programul
trebuie să fie capabil să învețe anumite gesturi de la personal calificat în fizioterapie.
Având aceste comportamente învățate, sistemul trebuie să ofere sugestii privind
modul în care trebuie executat un anumit exercițiu cât și informații privind
corectitudinea în execuția acestora.

Drept obiective, se dorește prezentarea unor algoritmi performanți de

recunoaștere a gesturilor ce vor fi folosiți pentru monitorizare medicală, proiectarea
unei aplicații ușor de utilizat și instalat cât și de întreținut. Deasemenea se dorește
optimizarea consumului de resurse hardware în procesarea algoritmilor ce vor fi
prezentați cât și programarea sistemului să poată oferi comenzi elementelor de
execuție a unei case inteligente.

5
2. Sistemul Microsoft Kinect

Sistemul Microsoft Kinect este compus dintr-o serie de senzori, a căror date
extrase sunt prelucrate de microprocesorul intern oferind aplicației la care acesta se
conectează informații esențiale, ușor de integrat în procesarea internă a aplicației.
Senzorii de care dispune MS Kinect (Figura 2.1) sunt următorii: cameră RGB 1280 x
960 rezoluție, IR senzor, set de 4 microfoane distribuite pe rama Kinect-ului, putând
astfel localiza sursa sunetului în spațiu, accelerometru pe 3 axe folosit pentru a obține
orientarea dispozitivului. Pe lângă acești senzori, a fost adăugat și un emitor de lumină
infraroșie ce propagă puncte de lumină IR în zona de funcționare. Câmpul de
vizualizare este de 43 grade la verticală și 57 grade la orizontală, motorul intern
asigurând o inclinație de +- 27 de grade. Rata la care sunt capturate imaginile fiind de
30 de cadre pe secundă. [6]

Figura 2.1 - Senzorul Microsoft Kinect

Modul de achiziție a datelor cât și recunoașterea elementelor de interes pentru

crearea scheletului uman, sunt posibile cu ajutorul unor procese complexe de calcul și
structurare a datelor ce în final sunt transmise prin cablul USB către device-ul ce
urmează a folosi datele extrase. Pentru a putea recunoaște scheletul uman, Microsoft
Kinect folosește un emitor de lumină infraroșie conceput de către compania Prime
Sense, conceptul fiind cunoscut în literatura de specialitate sub denumirea de lumină
structurată (structured light). Această modalitate de proiecție în spațiu a unui model
de lumină este foarte eficientă în obținerea distanței dorite între un punct luminos și
senzor. Modul în care modelul de lumină infraroșie proiectat (linii de lumină sau
puncte în cazul Microsoft Kinect) se deformează, permite hardware-ului să calculeze
distanța dintre punctele de lumină proiectate și senzor. În figura 2.2 se pot observa
punctele de lumină proiectate de către emitorul de lumină infraroșie.

6
 Figura 2.2 - Lumina infraroșie propagată în spațiul de funcționare

Obținerea informațiilor relevante se realizează combinând metoda luminii

structurate cu alte două modalități clasice folosite în vederea artificială și anume Depth
from focus și Depth from stereo [7]. Depth from focus îmbunătățește calitatea informațiilor
obținute din partea senorului IR. Kinect-ul folosește lentile astigmatice cu diferite
lungimi de focalizare pe coordonatele x și y. Așadar punctul proiectat devine o elipsă
a cărei orientare depinde de distanță.

Figura 2.3 - Forma punctului de lumină în funcție de distanță

Metoda Depth from stereo se folosește de principiul parallax care spune că un obiect
poate fi perceput diferit, văzut din diferite poziții ale observatorului. Calculul hartei
distanțelor se realizează în două etape. Etapa 1, harta distanțelor este obținută
analizând șablonul de lumini proiectat și comparându-l cu cel de referință.

Calculul distanței se realizează prin metoda triunghiularizării, sistemul

foloseşte lumina proiectată de emitor, captată de senzorul CMOS, comparând șablonul
de lumină proiectat cu cel din memorie folosit drept referință. Șablonul referință este
realizat capturând un plan la distanță cunoscută față de senzor și salvat în memoria
internă a Kinect-ului. Atunci când un punct de lumină este proiectat pe un obiect aflat
la o distanță mai mică sau mai mare față de șablonul de lumină de referință, imaginea
compusă din punctele infraroșii este distorsionată. Aceste distorsiuni sunt calculate

7
pentru fiecare punct printr-o procedură de corelare. Astfel pentru fiecare pixel se poate
calcula distanța pană la senzor.

Figura 2.4 - Calculul distanței folosind metoda triunghiularizării

În figura 2.4 este ilustrată relația dintre distanța unui obiect (punctul de lumina
k) la senzorul CMOS, cât și distanța de distorsiune D. Pentru a putea exprima poziția
în coordonate 3D, se va considera punctul de origine (0,0,0) în centrul senzorului IR.
Axa Z este perpendiculara pe planul imaginii, axa X este perpendiculara pe Z iar axa
Y este perpendiculara pe X și Z, fiind un sistem de coordonate de mâna dreaptă. Fie
un obiect amplasat în plan la distanța 𝑍0 față de senzor, iar punctele de lumina IR
capturate de pe suprafața obiectului vor fi mișcate cu un deplasament D pe direcția
axei X. [8]

D Z0 −Zk
= (2.1)
b Z0

Unde b reprezintă distanța dintre emitorul de lumină infraroșu și senzor.

𝑑 𝐷
= (2.2)
𝑓 𝑍𝑘

𝑍𝑘 denota distanța punctului k în planul obiectului, f fiind lungimea de focalizare a

camerei cu infraroșu iar d reprezintă distorsiunea obținută în spațiul imaginii.
Înlocuind D din ecuația 2.2 în 2.1 se va obține relația următoare:

𝑍0
𝑍𝑘 (2.3)
𝑍
1+ 0𝑑
𝑓𝑏

8
Ecuația 2.3 reprezintă modelul matematic al distanței între punctul de lumină
infraroșie și senzor, calculată din distorsiunea șablonului de lumină.

𝑍𝑘
𝑋𝑘 = − (𝑥 − 𝑥0 + 𝛿𝑥) (2.4)
𝑓 𝑘

𝑍𝑘
𝑦𝑘 = − (𝑦𝑘 − 𝑦0 + 𝛿𝑦) (2.5)
𝑓

Coordonatele planimetrice ale fiecărui punct de lumină pot fi calculate cu ajutorul

relației 2.4 respectiv 2.5, unde 𝑋𝑘 și 𝑌𝑘 sunt coordonatele fiecărui punct, 𝑋0 și 𝑌0
reprezentând coordonatele punctului principal, iar δx și δy fiind corecturile aplicate
datorită distorsiunii lentilelor. [8]

2.1 Modelul geometric Kinect

Modelarea matematică se realizează ținând cont de camera RGB, emitorul IR și

senzorul IR. Modelul geometric, ce proiectează un punct aflat în spațiu 3D pe o
imagine [𝑢, 𝑣]𝑇 este dat de relația 2.5.1. [9]

𝑢 𝑠
[𝑣 ] = 𝐾 [ 𝑡 ] (2.5.1)
1 1

𝑠 𝑝 2 𝑘3 𝑝𝑞 + 𝑘4 (𝑟 2 + 2𝑝2 )
[ 𝑡 ] = (1 + 𝑘1 𝑟 2 + 𝑘2 𝑟 4 + 𝑘5 𝑟 6 ) [𝑞 ] + [2 𝑘4 𝑝𝑞 + 𝑘3 (𝑟 2 + 2𝑝2 )] (2.6)
1 0 1

𝑝𝑧
2 2 2
𝑟 = 𝑝 + 𝑞 , [𝑞 𝑧] = 𝑅(𝑋 − 𝐶) (2.7)
𝑧

9
 Figura 2.5 - Modelul geometric Kinect

Unde k = [𝑘1 , 𝑘2 , … … , 𝑘5 ] reprezintă coeficienți de distorsiune, K matricea de

calibrare, R rotația Kinect-ului, C centrul camerei. [9]

Senzorul IR returnează inversul distanței d pe axa z pentru fiecare pixel [𝑢, 𝑣]𝑇
al camerei IR astfel:

𝑢 − 𝑢0
𝑥 𝑣 − 𝑣0
[𝑦 ] = [ 1 1 𝑐 ] (2.8)
0
𝑑 −
𝑐1 𝑧 𝑐1

Unde u și v sunt obținuți din ecuația 2.6, distanța pe axa z de ecuația 2.7. X reprezintă
coordonatele 3D ale unui punct, iar 𝑐1 și 𝑐0 parametrii modelului. Asociind sistemul
de coordonate ale Kinect-ului cu cel al senzorului IR, astfel 𝑅𝐼𝑅 = 𝐼, 𝐶𝐼𝑅 = 0. Un punct
3D 𝑋𝐼𝑅 este compus din calculul [x,y,d] din imaginea de adâncime astfel:

1 𝑥 + 𝑢0
−1
𝑋𝐼𝑅 = 𝑑𝑖𝑠 −1 (𝐾𝐼𝑅 [𝑦 + 𝑣0 ] , 𝑘𝐼𝑅 ) (2.9)
𝑐1 𝑑 + 𝑐0
1

Iar proiecția punctului pe imaginea RGB fiind:

𝑢𝑅𝐺𝐵 = 𝐾𝑅𝐺𝐵 𝑑𝑖𝑠(𝑅𝑅𝐺𝐵 (𝑋𝐼𝑅 − 𝐶𝑅𝐺𝐵 ), 𝑘𝑅𝐺𝐵 ) (2.10)

unde dis este funcția de distorsiune dată de ecuația 2.6, 𝑘𝐼𝑅 , 𝑘𝑅𝐺𝐵 sunt parametrii de
distorsiune ai camerei IR și RGB. 𝐾𝐼𝑅 este matricea de calibrare a senzorului IR.
𝐾𝑅𝐺𝐵 , 𝑅𝑅𝐺𝐵 , 𝐶𝑅𝐺𝐵 sunt matricile de calibrare, rotație și centrul camerei RGB. [9]
10
2.2 Posibile cauze ale achiziționării datelor eronat

Posibile erori în achiziția datelor se pot datora următorilor factori: senzorul

CMOS, poziționarea Kinect-ului în spațiul de funcționare sau proprietățile
suprafețelor obiectelor. Senzorul poate fi calibrat greșit din fabrică, însă un alt factor
de menționat este lumina ce pătrunde în încăperea unde este utilizat sistemul. Prea
multă lumină poate influența analiza distorsiunilor, deoarece contrastul de lumină
poate afecta recunoașterea formei punctului de lumină infraroșie proiectat. Se
recomandă o poziționare a persoanei ce folosește sistemul Kinect-PC la cel puțin 1.8
m. Deasemenea suprafața obiectelor pe care este proiectată lumina, poate influența
foarte mult rezultatele achiziției deoarece suprafețele lucioase pot amplifica raza de
lumină, rezultând în achiziționarea unor date eronate.

2.3 Rezoluția imaginii de adâncime și densitatea punctelor de

lumină IR

Rezoluția imaginii de adâncime este de 640 x 480 pixeli, iar densitatea punctelor
luminoase descrește odată cu majorarea distanței dintre obiect și senzor. Dacă se
consideră densitatea punctelor ca fiind numărul de puncte luminoase per unitate de
suprafață, în timp ce numărul de puncte proiectate rămâne constant, aria este
proporțională cu distanța la pătrat dintre senzor și obiect iar densitatea punctelor pe
planul xy este invers proporțională cu distanța la pătrat de la senzor la obiect.
Rezoluția imaginii de adâncime/distanță este determinată de numărul de biți per pixeli
folosiți pentru a calcula distorsiunea. Aceasta este înmagazinată în valori întregi
reprezentate pe 11 biți, unde un bit este inversat pentru a marca punctele de lumină
neafectate de distorsiune. [8]

2.4 Identificarea punctelor luminoase ce formează articulaţii

Un alt factor ce influențează bunul comportament al Kinect-ului este abilitatea

acestuia de a își adapta achiziția datelor în funcție de zona în care este pus în funcțiune.
Așadar acesta când este pornit, realizează o scanare a încăperii, marcând în memorie
zonele libere în care persoana se poate mișca. Acestă scanare permite detecţia rapidă
a încheieturilor scheletului. Se recomandă mișcarea cât mai rară a poziției Kinect-ului,
deoarece cu timpul, acesta realizează achiziții cât mai corecte. Pentru a învăța sistemul
să recunoască încheieturile unui schelet, s-a utilizat un algoritm de machine learning
conceput de inginerul Jamie Shotton, responsabil al departamentului de cercetare
Microsoft din cadrul Universitații Cambridge. Echipa sa a reușit să mapeze datele
11
experimentale în modele de referință cu ajutorul înregistrării a diferitor persoane de
vârste diferite, dimensiuni diferite, înalțimi diferite și nu în ultimul rând îmbrăcate cu
o gamă largă de haine. [10] Plecând de la 100.000 de imagini de adâncime reale, cu
ajutorul programelor de modelare au fost realizate pentru fiecare în parte alte zeci de
poziții obținând aproximativ 1.000.000 de date folosite pentru baza de date a Kinect-
ului.

Pentru identificarea scheletului, Kinect-ul trebuie mai intâi să identifice pixelii

corpului uman folosind o parsare a fiecărui pixel căutând diferența de adâncime,
impunând o valoare de prag. [7]

Figura 2.6 - Identificarea pixelilor analiând diferența de adâncime

Având în evidență pixelii ce corespund doar corpului uman, se analizează fiecare pixel
printr-un set de algoritmi decizionali (figura 2.7) ce prezice probabilitatea de a aparține
unei anumite părți a corpului.

Figura 2.7 - Set algoritmi decizionali

Nodul părinte reprezintă o valoare de prag, iar în nodurile copil se salvează

distribuția ce asignează un pixel unei anumite părți a corpului uman. Pentru a clasifica
un pixel, acesta se verifică cu fiecare algoritm decizional (figura 2.7) și se calculează
media tuturor distribuțiilor. Algoritmul decizional se obține cu ajutorul imaginilor din
baza de date. [7]

12
 Pentru fiecare cadru numărul pașilor necesari pentru a îl procesa este N*T*L,
unde N reprezintă numărul pixelilor, T este numărul algoritmilor de decizie, L este
numărul nivelelor ce trebuiesc străbatute în procesare. N poate fi între 0 și 19.000, T
este egal cu 3 iar L egal cu 20. Pe lângă acești pași, procesarea fiecărui pixel se face
independent pentru fiecare algoritm decizional. [7]

Estimarea pozițiilor încheieturilor se realizează folosind algoritmul mean-shift,

metodă de clusterizare a datelor ce nu necesită cunoașterea numărului de clustere sau
forma acestora. Microsoft Kinect recunoaște 20 de încheieturi precum în figura 2.8.

Figura 2.8 - Încheieturile identificate de Microsoft Kinect

2.5 Algoritmul Mean-Shift

După ce se obține probabilitatea fiecărui pixel de a aparține unei anumite părți

a corpului atribuirea se realizează cu ajutorul algoritmului de deplasare la medie. Fie
n date 𝑥𝑖 , 𝑖 = 1, … , 𝑛 pe un spațiu d-dimensional 𝑅 𝑑 , densitatea nucleului multivariabil
estimat obținut cu nucleul K(x) și raza ferestrei h. [11]

𝑛
1 𝑥 − 𝑥𝑖
𝑓(𝑥) = 𝑑 ∑ 𝐾( ) (2.11)
𝑛ℎ ℎ
𝑖=1

Gradientul funcției densitate de probabilitate estimată este:

13
 𝑛
2𝑐𝑘,𝑑 𝑥 − 𝑥𝑖 2
𝛻𝑓(𝑥) = 𝑑+2 ∑(𝑥𝑖 − 𝑥)𝑔 (‖ ‖ )
𝑛ℎ ℎ
𝑖=1
𝑛 𝑛 𝑥 − 𝑥𝑖 2
2𝑐𝑘,𝑑 𝑥 − 𝑥𝑖 ∑ 2𝑥𝑖 𝑔(‖ ‖ )
𝑖=1 ℎ
= 𝑑+2 [∑ 𝑔 (‖ ‖ )] [ − 𝑥] (2.12)
𝑛ℎ ℎ 𝑛 𝑥 − 𝑥𝑖 2
𝑖=1 ∑𝑖=1 𝑔(‖ ‖ )
ℎ

Unde g(s)=−𝑘̀(𝑠). Primul termen este proporțional cu densitatea estimată la pasul x

2
calculată cu nucleul G(x)=𝑐𝑔,𝑑 𝑔(‖𝑥‖ ) iar termenul 2:

𝑥 − 𝑥𝑖 2
∑𝑛𝑖=1 𝑥𝑖 𝑔(‖ ‖ )
ℎ
𝑚ℎ (𝑥) = − 𝑥 (2.13)
𝑥 − 𝑥𝑖 2
∑𝑛𝑖=1 𝑔(‖ ‖ )
ℎ

reprezintă deplasarea la medie. Vectorul de deplasare la medie este îndreptat mereu

în direcția densității maxime a punctelor. Algoritmul este garantat să conveargă către
un punct a cărui funcție de gradient este 0. [11]

Figura 2.9 - Clasificarea pixelilor în funcție de încheieturi

Pentru cele 20 de încheieturi identificate în fiecare cadru, hardware-ul intern al

Kinect-ului returnează prin USB, coordonatele relative la sistemul de coordonate a
senzorului pentru fiecare punct identificat precum în Figura 2.9. Datele sunt transmise
cu ajutorul unui cadru ce are formatul următor :

3D Data = 𝑃𝑖𝑗 (𝑘), 𝑖 = 1,2, … ,20, 𝑗 = 𝑥, 𝑦, 𝑧, 𝑘 = 1,2, … 𝑛

Dimensiunea unui cadru este de 60 de elemente (20 încheieturi x 3 coordonate).

Cadrele pot fi vizualizate astfel:
14
Cadrul N: 𝑃1𝑥 (𝑁) 𝑃2𝑥 (𝑁) … 𝑃20𝑥 (𝑁) 𝑃1𝑦 (𝑁) 𝑃2𝑦 (𝑁) … 𝑃20𝑦 (𝑁) 𝑃1𝑧 (𝑁) 𝑃2𝑧 (𝑁) … 𝑃20𝑧 (𝑁)

Microsoft Kinect SDK dispune de metode deja implementate ce ajută foarte mult în
prelucrarea datelor obținute prin USB. Funcții precum, FrameRate ce permite
modificarea pasului de eșantionare, UseSkeletalTraking folosit pentru pornirea
identificării scheletului uman. Deasemenea se poate obține streaming color din partea
camerei video RGB, folosind funcția UseColor. Pentru a vizualiza imaginea de
adâncime se poate utiliza UseDepth. Folosind UseSkeletalTracking împreună cu un
event handler, ce este responsabil cu gestionarea obiectelor de tip KinectSkeleton la
sosirea fiecărui cadru în buffer, se pot accesa în mod particular coordonatele fiecărei
încheieturi.

În funcție de poziția utilizatorului, anumite încheieturi pot să nu fie captate în cadru.

Kinect-ul rezolvă această problemă estimând poziția încheieturilor ce nu sunt
vizualizate. Se poate ca în cazul în care acesta, se utilizează la o distanță mai mică de
1.8 m, să returneze majoritatea coordonatelor încheieturilor ca fiind (0,0,0). Acest
feedback se poate combate prin programarea aplicației să ignore respectivele obiecte
de tip KinectSkeleton până când va obține unul ce are toate coordonatele încheieturilor
diferite de 0.

Microsoft Kinect este un sistem inteligent de detecție a elementului uman,

reușind foarte bine și rapid să ofere informații privind evoluția în timp a scheletului
uman, folosindu-se de algoritmi matematici complecși pentru identificare. Având
aceste biblioteci, utilizarea acestuia a fost împrumutată și în alte domenii decât
industria jocurilor video.

15
3. Detecția și recunoașterea gesturilor

Aplicația dispune de două moduri de funcționare în care se evaluează o poziție

sau un gest, modul de asistență medicală și respectiv modul de comenzi automate
combinând detecția gesturilor cu cea a pozițiilor. Pentru recunoașterea gesturilor și a
pozițiilor, datele esențiale sunt stocate în 3 fișiere de tip Excel, local în folder-ul
aplicației. Kinect dispune de identificarea a 20 de încheieturi ce formează 5 lanțuri
osoase (1: cap-umăr centru-coloană-pelvis, 2: umăr drept-cot drept-încheietură
dreaptă-mână dreaptă, 3: umăr stâng-cot stâng-încheietură stangă-mână stângă, 4:
șoldul stâng-genunchi stâng-glezna stângă-talpa stângă, 5: șold drept-genunchi drept-
glezna dreaptă-talpa dreaptă). Cu ajutorul acestor 20 de încheieturi se pot forma 19
segmente pentru analiza datelor, cu ajutorul cărora se pot obține unghiuri relative la
segmentele părinte, date ce sunt folosite în analiza gesturilor.

3.1 Pregătirea datelor necesare

Datorită zgomotului ce apare inevitabil în achiziția datelor, anumite încheieturi

sunt identificate cu erori de poziționare, fapt ce rezultă într-o modificare continuă a
poziției unui segment, rezultând astfel în salvarea unor date eronate ce pot provoca o
recunoaștere dificilă sau eronată a pozițiilor sau a gesturilor. Combaterea acestui
comportament nedorit se poate efectua cu ajutorul unui filtru trece jos, însă apare un
alt efect nedorit și anume o întârziere în timpul de răspuns al manechinului 3D direct
proporțională cu pragul de tăiere al filtrului. Așadar pentru evitarea acestor
comportamente s-a ales reducerea numărului de segmente incluse în salvarea și
procesarea datelor la 11 precum se observă în figura 3.1. Aceste segmente pot fi
păstrate în cazul migrării programului pentru Kinect v2.

16
 Figura 3.1 - Segmentele luate în calcul pentru identificarea unui gest

Segmentele (cap-umăr centru, coloană-pelvis, pelvis-șold stâng, pelvis-șold

drept, glezna stângă-talpa stângă, glezna dreaptă-talpa dreaptă) au fost excluse
datorită fluctuațiilor în poziționare şi datorită impactului redus în recunoașterea
pozițiilor sau a gesturilor.

3.2 Recunoașterea statică sau a pozițiilor

Recunoaşterea poziţiilor este un pas esenţial în prezenta lucrare deoarece există

un mod de funcţionare în care se vor genera comenzi pentru case inteligente, în funcţie
de poziţia utilizatorului dar şi pentru recunoaşterea gesturilor folosind algoritmul
prezentat mai jos.

Metoda utilizată pentru recunoașterea pozițiilor respectiv a gesturilor

presupune obținerea unor vectori 3D ce reprezintă segmentele de interes. Calculul
vectorilor se efectuează folosind coordonatele a două încheieturi ce compun un
segment de interes precum în Figura 3.1.

𝑗𝑛𝑡𝑖 (𝑥𝑖 , 𝑦𝑖 , 𝑧𝑖 )

𝑗𝑛𝑡𝑗 (𝑥𝑗 , 𝑦𝑗 , 𝑧𝑗 )

17
 𝑣𝑖𝑗 = (𝑥𝑗 − 𝑥𝑖 , 𝑦𝑗 − 𝑦𝑖 , 𝑧𝑗 − 𝑧𝑖 )
⃗⃗⃗⃗ (3.1)

Algoritmului folosit pentru recunoașterea pozițiilor asigură robustețea

sistemului în cazul utilizării programului de către persoane cu înalțimi diferite însă nu
și în cazul poziționării aleator în spațiul de lucru. Această ultimă problemă semnalată
se rezolvă în două etape. Etapa 1 presupune centrarea coordonatelor fiecărui vector
𝑣𝑖𝑗 cu media aritmetică a coordonatelor x,y,z obținută din încheieturile LeftShoulder
⃗⃗⃗⃗
(umăr stâng, LS) și RightShoulder (umăr drept, RS). [12]

𝐿𝑆(𝑥𝑙𝑠 , 𝑦𝑙𝑠 , 𝑧𝑙𝑠 )

𝑅𝑆(𝑥𝑟𝑠 , 𝑦𝑟𝑠 , 𝑧𝑟𝑠 )

𝑥𝑟𝑠 + 𝑥𝑙𝑠
𝑋𝑐 =
2
𝑦𝑟𝑠 + 𝑦𝑙𝑠
𝑌𝑐 = (3.2)
2
𝑧𝑟𝑠 + 𝑧𝑙𝑠
{ 𝑍𝑐 = 2

Astfel pentru fiecare vector asemănător relației 3.1, se va scădea din coordonatele
acestuia 𝑋𝑐 , 𝑌𝑐 , 𝑍𝑐 , pentru a utiliza mai departe în program coordonatele centrate. În
etapa 2 se normalizează datele calculând distanța dintre LS și RS apoi împărțind
elementele vectorilor la această distanță.

𝑆𝐷 = √(𝑥𝑙𝑠 − 𝑥𝑟𝑠 )2 + (𝑦𝑙𝑠 − 𝑦𝑟𝑠 )2 + (𝑧𝑙𝑠 − 𝑧𝑟𝑠 )2 (3.3)

Folosind distanța calculată cu ecuația 3.3 în ecuația 3.4 se obțin vectorii de interes
centrați și normalizați.

𝑥𝑗 − 𝑥𝑖 𝑦𝑗 − 𝑦𝑖 𝑧𝑗 − 𝑧𝑖
𝑣𝑖𝑗 = (
⃗⃗⃗⃗ , , ) (3.4)
𝑆𝐷 𝑆𝐷 𝑆𝐷

Relația 3.4 garantează robustețea algoritmului indiferent de poziția

utilizatorului față de Kinect. Având aceste date prelucrate, aplicația salvează vectorii
de interes într-un document Excel însă aceste valori sunt insuficiente pentru
recunoașterea unei poziții. Atunci când aplicația este pornită sau când se salvează un
18
nou set de date, se vor încărca din fișier aceste segmente/vectori, în memorie pentru a
fi folosiţi în procesare.

Soluția propusă pentru recunoașterea pozițiilor cât și ulterior a gesturilor

constă în identificarea unică a fiecărui segment de interes din figura 3.1 cu ajutorul a
două unghiuri. [12]
𝜃(𝑌) = 𝑈𝑛𝑔ℎ𝑖𝑢𝑙 𝑑𝑖𝑛𝑡𝑟𝑒 𝑣𝑒𝑐𝑡𝑜𝑟 ș𝑖 𝑎𝑥𝑎 𝑝𝑜𝑧𝑖𝑡𝑖𝑣ă 𝑌 𝑎 𝑠𝑖𝑠𝑡𝑒𝑚𝑢𝑙𝑢𝑖 𝑑𝑒 𝑟𝑒𝑓𝑒𝑟𝑖𝑛ță 𝐾𝑖𝑛𝑒𝑐𝑡
𝜃(𝑋𝑍)
= 𝑈𝑛𝑔ℎ𝑖𝑢𝑙 𝑑𝑖𝑛𝑡𝑟𝑒 𝑝𝑟𝑜𝑖𝑒𝑐ț𝑖𝑎 𝑣𝑒𝑐𝑡𝑜𝑟𝑢𝑙𝑢𝑖 𝑝𝑒 𝑝𝑙𝑎𝑛𝑢𝑙 𝑋𝑍 ș𝑖 𝑎𝑥𝑎 𝑋 𝑎 𝑠𝑖𝑠𝑡𝑒𝑚𝑢𝑙𝑢𝑖 𝑑𝑒 𝑟𝑒𝑓𝑒𝑟𝑖𝑛ță 𝐾𝑖𝑛𝑒𝑐𝑡

Figura 3.2 - Unghiurile ce caracterizează un segment

Cu ajutorul acestor două unghiuri se poate identifica unic poziția unui segment
în cadrul achiziționat. În această lucrare s-au implementat două modalități de
recunoaștere a gesturilor statice, și anume metoda identificării liniare cât și metoda
identificării exponențiale.

A doua metodă precizată oferă performanțe mult mai bune decât prima, fiind puțin
mai costisitoare în privința pașilor de procesare. Metoda de identificare liniară
presupune calculul diferenței sumei de unghiuri a două poziții diferite precum:
11
𝑣 𝑣
𝜃𝑡 = ∑(|𝜃𝑌 𝑖 | + |𝜃𝑋𝑍𝑖 |) (3.5)
𝑖=1

Unde 𝑣𝑖 reprezintă segmentul cu numărul i din cei 11 de interes, obținut prin formula
3.4 iar 𝜃𝑡 reprezentând suma tuturor unghiurilor. Așadar se poate calcula diferența

19
sumelor unghiurilor a două poziții (cea de referință, învățată cu cea de testat captată
într-un anumit moment de timp)

𝑠𝑢𝑚𝑟𝑒𝑓 = |𝜃𝑟𝑒𝑓 − 𝜃𝑡𝑠 | (3.6)

Având în vedere că sistemul se va folosi de foarte multe poziții ce vor fi învățate

pe parcursul utilizării, poziția recunoscută este aceea ce deține 𝑠𝑢𝑚𝑟𝑒𝑓 , o proprietate
a clasei Poses, cu cea mai mică valoare. Fie S, mulțimea tuturor pozițiilor învățate, iar
poziția de referință cu cel mai mic 𝑠𝑢𝑚𝑟𝑒𝑓 se poate calcula astfel:

𝑃𝑚𝑖𝑛 = min (𝑠𝑢𝑚𝑟𝑒𝑓 ) (3.7)

𝑟𝑒𝑓∊𝑆

Această metodă nu este foarte eficientă atunci cand două poziții sunt
asemanătoare. Din acest motiv se preferă utilizarea metodei de identificare
exponențială deoarece chiar și dacă un singur segment este puțin diferit între cele două
poziţii, atunci unghiurile acelui vector vor diferenția semnificativ cele două poziții. În
acest caz rezultatul funcției exponențiale a diferenței individuale a unghiurilor
aceluiaș tip de segment din cele două poziții este calculat și însumat. [12]

𝑣 𝑣 𝑣
𝜃𝑝 𝑖 = |𝜃𝑦 𝑖 | + |𝜃𝑥𝑧𝑖 | (3.8)

11
𝑣 𝑣
𝑠𝑢𝑚𝑟𝑒𝑓 = ∑ 𝑒𝑥𝑝(|𝜃𝑟𝑒𝑓
𝑖
− 𝜃𝑡𝑠𝑖 |) (3.9)
𝑖=1

Aplicația capturează scheletul oferit de Kinect la eşantioane de 300 de ms,

compară achiziția cu informațiile din baza de date și decide cărei poziții îi este similară
poziția de test. Folosind doar aceste două metode în identificare, algoritmul va returna
mereu că există o poziție recunoscută chiar dacă aceasta nu este învațată în baza de
date deoarece există întotdeauna un minim. Pentru a putea spune despre o poziție că
nu poate fi identificată, trebuie ca minimul acesteia să se afle peste o anumită valoare
de prag impusă. Valoarea de prag se impune după ce sistemul are salvat în baza de
date un anumit număr de poziții cât mai diferite între ele. Se testează 𝑠𝑢𝑚𝑟𝑒𝑓 returnat
pentru poziții ce nu au fost învățate apoi se calculează media aritmetică a tuturor
valorilor 𝑠𝑢𝑚𝑟𝑒𝑓 obținute iar valoarea obținută se trece drept valoare de prag. În cazul
aplicației prezentate se va folosi valoarea de prag egală cu 15.5.

20
3.3 Programarea sistemului să fie invariant la rotația corpului
față de Kinect

Atunci când subiectul nu stă poziţionat paralel cu Kinect-ul trunchiul formează

un anumit unghi cu axa X. Se presupune că pozițiile din baza de date sunt învățate
stând paralel cu senzorul. Atunci când se achiziționează o poziție de test se calculează
unghiul format de umerii subiectului și axa X a sistemului de coordonate Kinect. Astfel
vectorul ce unește umărul central cu umărul stâng este garantat că se rotește odată cu
trunchiul. Se calculează unghiul de rotație cu formula:

𝑣1𝑥
𝜃 = cos −1 ( ) (3.10)
⃗⃗⃗⃗⃗
|𝑣 1 |

Unde, θ este unghiul dintre |𝑣 ⃗⃗⃗⃗⃗

1 | și axa pozitivă X iar 𝑣1𝑥 denotă componenta x a
vectorului 𝑣1 . Se obține un unghi cuprins între 0 și 90 de grade. După ce se obține acest
unghi, trebuie calculată orientarea acestuia care se calculează cu ajutorul diferenței
coordonatelor Z a încheieturii centrale și a umărului drept. Dacă această diferență este
mai mică decât 0, unghiul calculat cu formula 3.10 este negat. [12]

𝑍𝑈𝑀Ă𝑅_𝐶𝐸𝑁𝑇𝑅𝑈 − 𝑍𝑈𝑀Ă𝑅_𝐷𝑅𝐸𝑃𝑇 < 0 => 𝜃 = −𝜃 (3.11)

După ce se obține aceast unghi, cei 11 vectori de interes trebuiesc rotiți pe axa Y pentru
a exclude rotația nedorită a persoanei. [12]

3.4 Recunoașterea dinamică sau a gesturilor

Gesturile reprezintă o serie de poziţii statice concatenate cu ajutorul unei liste.

Acestea sunt salvate în memorie cu ajutorul unei clase numită „Gestures”.
Proprietăţile acesteia fiind numele gestului, listă de tipul clasei „Poses” precum şi listă
de tipul „KinectSkeleton” ce deţine coordonatele în spaţiul Kinect pentru a putea
exemplifica gestul utilizatorului.

public String nume_gest;

private List<Poses> gesture;
private List<KinectSkeleton> exemplu_gest;

21
Pentru recunoaşterea dinamică s-au implementat două tipuri de algoritmi și anume
unul bazat pe metoda Dynamic Time Warping iar cel de al doilea a constat în folosirea
algoritmului de recunoaștere a gesturilor statice pentru a recunoaște un gest.

Metoda 1 s-a dovedit a fi foarte eficientă în detecția și recunoașterea gesturilor, fiind

foarte acurată și rapidă.

3.4.1 Recunoașterea dinamică folosind algoritmul Dynamic

Time Warping

În analiza seriilor temporale, Dynamic Time Warping (DTW) este un algoritm

folosit pentru măsurarea similaritudinilor între două secvenţe temporale ce pot varia
în timp și viteză. DTW a fost aplicat în analiza secvenţelor temporale audio, video și
orice set de date ce se poate transforma într-o secvență liniară. O aplicabilitate foarte
cunoscută a algoritmului DTW este aceea de a fi folosit în recunoaștere vocală și
semnătură digitală.

Scopul principal al algoritmului DTW este acela de a compara două serii timp X =
(𝑥1 , 𝑥2 , … , 𝑥𝑁 ) de lungime N ∊ N și Y = (𝑦1 , 𝑦2 , … , 𝑦𝑀 ) de lungime M ∊ N. Aceste serii
pot reprezenta semnale discrete. Pentru a stabili similaritudinea între două secvențe
se va defini un spațiu caracteristic notat cu Ƒ. Atunci X și Y ∊ Ƒ pentru n ∊ [1:N] și m
∊ [1:M]. [13] Pentru a compara aceste două secvențe, este necesară includerea unei
variabile numită variabilă locală de cost sau distanța locală măsurată ce este definită
printr-o funcție:

𝑐: Ƒ𝑥Ƒ → 𝑅 ≥ 0 (3.12)

De obicei, c(x,y) este mic (cost scăzut) dacă x și y sunt asemanătoare și invers, c(x,y)
este mare (cost ridicat) dacă acestea diferă.

Figura 3.3 - Două serii de timp comparate

22
 Figura 3.4 - Matricea de cost a două secvenţe

Figura 3.4 reprezintă matricea de cost a două secvenţe X (pe axa verticală) și Y
(pe axa orizontală) calculată cu distanța Manhattan (modulul diferenței) drept costul
local c. Regiunile de cost scăzut sunt indicate de nuanţe închise iar regiunile de cost
ridicat fiind indicate în nuanţe deschise. Fiecare pereche de elemente a secvențelor X
și Y compun împreună matricea de cost C ∊ 𝑅 𝑁𝑥𝑀 definită prin C(n,m) = c(𝑥𝑛 , 𝑦𝑚 ).
După formarea acestei matrici, scopul algoritmului DTW este de a găsi o aliniere între
X și Y ce oferă costul total minim. [13]

Un drum de cost minim (N,M) este o secvență p = (𝑝1 , 𝑝2 , … , 𝑝𝑙 ) cu 𝑝𝑙 = (𝑛𝑙 , 𝑚𝑙 ) ∊

[1: 𝑁] 𝑥 [1: 𝑀] pentru l ∊ [1: L] satisfăcând următoarele condiții:

(i) Condiția de limitare, drumul de cost începe în stânga jos a matricii din figura 3.4 și
se termină în dreapta sus; 𝑝1 = (1,1) ș𝑖 𝑝𝑙 = (𝑁, 𝑀).
(ii) Condiția de monotonie, în explorarea drumului algoritmul nu se va întoarce
niciodata cu un pas înapoi; 𝑛1 ≤ 𝑛2 ≤ 𝑛3 … ≤ 𝑛𝑙 ș𝑖 𝑚1 ≤ 𝑚2 ≤ ⋯ ≤ 𝑚𝑙
(iii) Condiția dimensionării pașilor; După p pași în aceeași directie, nu se permite
înaintarea cu încă un pas pe aceeași direcție, înainte de a se păși de q ori pe direcția
diagonală, 𝑝𝑙+1 − 𝑝𝑙 ∊ {(1,0), (0,1), (1,1)} 𝑝𝑒𝑛𝑡𝑟𝑢 𝑙 ∊ [1: 𝐿 − 1]. [13]

Se observă cum condiția (iii) implică condiția de monotonie (ii). Costul total 𝑐𝑝 (𝑋, 𝑌) a
unui drum de cost p pentru secvențele X și Y cu respect la costul local c corespunzător
unui element din matrice este definit astfel:

𝑐𝑝 (𝑋, 𝑌) = ∑ 𝑐(𝑥𝑛𝑙 , 𝑦𝑚𝑙 ) (3.13)

𝑙=1

În final un drum de cost optim între X și Y este definit de formula 3.14, deoarece pentru
oricare 2 secvențe se obţin mai multe drumuri de cost ce au valori 𝑐𝑝 diferite. [13]

𝐷𝑇𝑊(𝑋, 𝑌) = 𝑐𝑃∗ (𝑋, 𝑌) = min{𝑐𝑝 (𝑋, 𝑌)|𝑝 𝑒𝑠𝑡𝑒 𝑢𝑛 𝑑𝑟𝑢𝑚 𝑑𝑒 𝑐𝑜𝑠𝑡 (𝑁, 𝑀)} (3.14)
23
 Pentru a determina un drum optim ar trebui verificată fiecare posibilitate de
calcul între X și Y. O asemenea procedură ar duce la o complexitate de calcul
exponențială cu lungimea N și M. Pentru simplitate se va implementa un algoritm de
complexitate O(NM). Fiind definite secvențele X(1:n) = (𝑥1 , 𝑥2 … , 𝑥𝑛 ) pentru n ∊ [1:N]
iar Y(1:m) = (𝑦1 , 𝑦2 … , 𝑦𝑚 ) pentru m ∊ [1:M] se va nota:

𝐷(𝑛, 𝑚) = 𝐷𝑇𝑊(𝑋(1: 𝑛), 𝑌(1: 𝑚)) (3.14)

Valorile D(n,m) definesc o matrice N x M, ce reprezintă matricea de cost

acumulat. O pereche (n,m) va face referire la accesarea unui element din matricea de
cost C sau a matricii de cost acumulat D. Teorema următoare prezintă cum D se poate
calcula eficient.

Teorema 3.1 Matricea de cost acumulat D satisface următoarele identități: 𝐷(𝑛, 1) =

∑𝑛𝑘=1 𝑐(𝑥𝑘 , 𝑦1 ) 𝑝𝑒𝑛𝑡𝑟𝑢 𝑛 ∊ [1: 𝑁], 𝐷(1, 𝑚) = ∑𝑚
𝑘=1 𝑐(𝑥1 , 𝑦𝑘 ) 𝑝𝑒𝑛𝑡𝑟𝑢 𝑚 ∊ [1: 𝑀] iar

𝐷(𝑛, 𝑚) = min{𝐷(𝑛 − 1, 𝑚 − 1), 𝐷(𝑛 − 1, 𝑚), 𝐷(𝑛, 𝑚 − 1)} + 𝑐(𝑥𝑛 , 𝑦𝑚 ) (3.15)

pentru 1 < n ≤ N și 1 < m ≤ M.

Demonstrație. Fie m = 1 și n ∊ [1,N], atunci există o singură cale de parcurgere a

matricii între Y(1:1) și X(1:n) având un cost total ∑𝑛𝑘=1 𝑐(𝑥𝑘 , 𝑦1 ) ceea ce demonstrează
formula 3.15 pentru D(n,1).

Teorema 3.1 pemite calculul recursiv a matricii D. Inițializarea se poate efectua

extinzând matricea D cu o linie și o coloană suplimentară setând D(n,0) = ∞ pentru n
∊ [1:N], D(0,m) = ∞ pentru m ∊ [1:M], și D(0,0) = 0. Astfel recursivitatea formulei 3.15
este valabilă pentru n ∊ [1:N] și m ∊ [1 : M]. Algoritmul este următorul:

Date de intrare: Matricea de cost acumulat D

Date de iesire: Drumul de cost minim p*

Procedură: p* = (𝑝1 , … , 𝑝𝐿 ) este calculat recursiv începând cu 𝑝𝐿 = (𝑛, 𝑚). Prespupunem 𝑝𝑙 =

(𝑛, 𝑚) 𝑎 𝑓𝑜𝑠𝑡 𝑐𝑎𝑙𝑐𝑢𝑙𝑎𝑡. În cazul în care (n,m) = (1,1), dacă l = 1 se oprește calculul,altfel:

(1, 𝑚 − 1), 𝑑𝑎𝑐𝑎 𝑛 = 1

𝑝𝐿 = { (𝑛 − 1,1), 𝑑𝑎𝑐𝑎 𝑚 = 1
𝑎𝑟𝑔𝑚𝑖𝑛{𝐷(𝑛 − 1, 𝑚 − 1), 𝐷(𝑛 − 1, 𝑚), 𝐷(𝑛, 𝑚 − 1)}, 𝑝𝑒𝑛𝑡𝑟𝑢 𝑟𝑒𝑠𝑡𝑢𝑙 𝑣𝑎𝑙𝑜𝑟𝑖𝑙𝑜𝑟
(3.16)

24
 Figura 3.5 - (a)Matricea de cost C și (b) matricea de cost acumulat D și drumul
optimal p*

În prezenta lucrare, metoda DTW a fost folosită pentru recunoașterea gesturilor

deoarece aceasta nu depinde de timpul de execuție al unui gest. Timpul de execuție
depinde de la un pacient la altul. Important este ca exercițiile să fie realizate complet
și corect. La fel ca și în cazul recunoașterii gesturilor statice, algoritmul DTW are
nevoie să compare un gest de test cu unul sau mai multe de referință din baza de date.
Din acest motiv atunci când se învață un nou gest, acesta este salvat într-un document
Excel. Un gest este compus dintr-o serie de poziții, captate la un anumit pas de
eșantionare. Atunci când se compară un gest de test cu unul de referință se obține o
valoare de distorsiune (drumul optim p*), dacă aceasta este mai mică decât un prag
impus în urma realizării mai multor probe, atunci se consideră că gestul de referință a
fost recunoscut. În majoritatea lucrărilor de recunoaștere a gesturilor folosind
Microsoft Kinect, dezvoltatorii preferă achiziţionarea directă a coordonatelor 3D a
fiecărei încheieturi și apoi se aplică algoritmul DTW. Pentru a păstra structura de
achiziție a unei poziții, algoritmul DTW implementat folosește datele vectorilor de
interes (segmentelor) din figura 3.1.

T(t) = [𝑣1𝑥 (𝑡), 𝑣1𝑦 (𝑡), 𝑣1𝑧 (𝑡),…, 𝑣11𝑥 (𝑡), 𝑣11𝑦 (𝑡), 𝑣11𝑧 (𝑡)], t=1,2,...,T (3.17)

R(r) = [𝑣1𝑥 (𝑟), 𝑣1𝑦 (𝑟), 𝑣1𝑧 (𝑟),…, 𝑣11𝑥 (𝑟), 𝑣11𝑦 (𝑟), 𝑣11𝑧 (𝑟)], r=1,2,…,R (3.18)

3.17 poate fi considerat secvența X iar R(r) secvența Y. Punctul de start și de final fiind
(T(1) , R(1)) = (1,1) și (T(M) , R(M)) = (T,R). [13]

3.4.1.2 Recunoașterea dinamică aplicată

Algoritmul generalizat prezentat în secțiunea 3.4.1 a fost adaptat pentru stilul

de programare orientat obiect C#. Pentru a se stoca datele necesare unei poziții s-a
declarat o clasă numita „Poses” ce deține toate informațiile necesare algoritmului
25
(coordonatele vectorilor de interes prelucrați precum în secțiunea 3.2). Pentru a se
trimite datele spre analiză precum în 3.17 s-a ales utilizarea unui buffer de 32 de poziții
ce este analizat în permanență doar până la poziția la care a fost completat. Buffer-ul
se reinițializează atunci când se recunoaște un gest sau se atinge limita de 32 de poziții
înregistrate.

Așadar metoda de recunoaștere folosită primește drept parametrii, lista de

poziții ce se dorește a fi analizată împreună cu lista de gesturi (un gest este format
dintr-o listă de poziții) ce au fost selectate pentru a fi luate în considerare.

Algoritmul utilizat:

Date intrare : lista de poziții ce trebuie analizată, lista de gesturi selectată

Date ieșire : numele gestului recunoscut
Procedură: se salvează numărul de poziții din fiecare listă apoi se verifică dacă distanța
(Manhattan) dintre ultimile poziții a fiecărei liste este mai mică decât o valoare de prag impusă.
Dacă da, atunci se continuă cu analiza distanței DTW , 3.16 ce analizează fiecare posibilitate
de terminare a buffer-ului.
Dacă la final, rezultatul analizei 3.16 este mai mic decât o valoare impusă atunci gestul
respectiv a fost recunoscut și se oferă utilizatorului numele acestuia.

3.4.2 Recunoașterea dinamică folosind algoritmul de

recunoaștere a gesturilor statice

Gesturile de referință sunt învățate pas cu pas la comanda utilizatorului, fără a

se mai folosi o eșantionare în achiziția datelor de 200 ms. Aceste date sunt salvate într-
o bază de date separată și sunt folosite ca referință în procesul de recunoaștere.

În timpul execuției se achiziționează la fiecare 200 ms noi informații privind

poziția pacientului, și sunt stocate într-un buffer. Lista de poziții nou formată, se
pasează algoritmului atunci când dimensiunea buffer-ului este cel puțin egală cu
dimensiunea celui mai lung gest. Fie 𝐺𝑖,𝑟𝑒𝑓 = (𝑝1 , 𝑝2 , … , 𝑝𝑛 ), 𝑛 ∊ 𝑁, 𝑖 ∊ 𝑁 gesturile de
referință iar 𝐺𝑡𝑒𝑠𝑡 = (𝑝1 , 𝑝2 , … , 𝑝𝑚 ), 𝑚 ∊ 𝑁, atunci lista de test se va procesa când m ≥ n.
Fiind această condiție îndeplinită toate pozițiile ce compun un gest de referinţă, sunt
concatenate cu ajutorul unei liste apoi comparate pe rând cu fiecare poziție disponibilă
în buffer. Algoritmul folosit fiind următorul:

Date de intrare: Lista de poziții (buffer), Lista de poziții de referință ce compun gesturile
Date de ieșire: Numele gestului recunoscut
Procedură: Pentru fiecare poziție din buffer se compară asemănarea acesteia cu fiecare
poziție de referință folosind metoda de calcul prezentată în secțiunea 3.2
Se parsează lista cu poziții de referință și se caută poziția cu valoarea 3.9 cea mai mică.
Apoi se verifică dacă această vloare nu depășește valoarea de prag impusă.
Dacă depășește valoarea de prag, poziția nu aparține niciunui gest și se trece la analiza
următoarei poziții din buffer.
26
 Daca nu depășește valoarea de prag, se verifică dacă poziția anterioară celei analizate a
fost recunoscută. Dacă da atunci și aceasta poate fi la rândul ei validată, altfel se va aștepta
validarea celei anterioare prin trimiterea unui nou set de poziții către buffer.
După ce se verifică fiecare poziție din buffer, se va testa pentru fiecare gest dacă are toate
pozițiile din listă recunoscute. Gestul ce raspunde adevărat la această condiție de test este cel
recunoscut.
Reinițializarea tuturor pozițiilor de referință ca fiind nerecunoscute pentru analiza
următorului set de date.

Algoritmul prezentat anterior oferă rezultate mulțumitoare atunci când gestul

nu este unul complex și format din poziții cât mai diferite, analiza rezultatelor este
prezentată în capitolul 6 rezultate. Având în vedere complexitatea algoritmului puterea
de calcul nu este ridicată iar procesorul nu este solicitat precum în cazul algoritmului
3.4.

27
4.Structura și funcțiile sistemului

Dezvoltarea aplicației necesită o serie de programe ce cooperează pentru a

putea oferi un model 3D animat, conceput pentru a oglindi pe ecran mișcările
pacientului.

Programul îmbină utilizarea modulului de dezvoltat jocuri Microsoft XNA cu

framework-ul DigitalRune pentru animarea modelului grafic. Microsft XNA este un
utilitar bazat pe .NET Framework conceput pentru dezvoltarea jocurilor ce rulează pe
platorme precum Windows NT, Windows Phone și Xbox 360. XNA a fost anunțat de
către Microsoft în anul 2004 iar de la versiunea 1.0 s-a ajuns până la versiunea 4.0 cu
suport DirectX 11, eliberată în anul 2010. Compania renunță la dezvoltarea acestui
framework în anul 2013 și anunță că oprește suportul tehnic pentru acest modul.

Pentru animarea în timp real a modelului grafic s-a utilizat un framework

numit Digital Rune ce este la rândul său un motor grafic pentru dezvoltarea jocurilor.
Acesta oferă diferite biblioteci menite să ușureze munca dezvoltatorilor software, cât
și o bibliotecă dedicată animației unui model grafic utilizând informațiile primite din
partea Kinect-ului. DigitalRune a fost declarat în anul 2016 software open-source.
Platformele suportate de acest framework fiind Windows Phone, Linux, Xbox360, Mac
OS X precum și Android sau Unity Game Engine.

Modelul grafic a fost dimensionat și randat utilizând programul 3DS Max

Studio 2014, folosit pentru modelări grafice precum și animații 3D. S-a utilizat 3DS
Max deoarece acesta oferă scheletizarea modelului compatibilă cu framework-ul
Digital Rune.

Figura 4.0 - Modelul grafic

28
4.1 Modurile de funcționare

Aplicația este concepută pentru a izola modurile de funcționare. Astfel, au fost

concepute 5 stări în care programul se poate afla. Starea 0 este accesată atunci când
programul pornește și se încarcă datele din fișier. Starea 1 este meniul principal în care
utilizatorul își alege funcțiile necesare pentru a îi servi utilizării. În cazul în care
utilizatorul nu conecteaza Kinect-ul la unitate atunci se va semnala acest amănunt pe
ecran cu mesajul „Could not initialize Kinect device, please check the connection.”

Figura 4.1.1 - Meniul de start al aplicației

Următoarele 3 stări posibile, modul “Learn Gestures” în care sistemul poate învăța atât
gesturi cât și poziții. Deasemenea există mai multe posibilități pentru învățarea
acestora ce vor fi prezentate în secțiunea 4.2. Modul “Start” de funcționare este acela
de supraveghere a pacientului în execuția exercițiilor. În acest mod este implementată
și o interfață grafică ce permite selectarea tipurilor de exerciții cât și modul de
recunoaștere dorit. Ultimul mod de funcționare „User Commands” este conceput
pentru casele inteligente ce pot integra un asemenea sistem pentru modificarea stării
spațiului înconjurător.

Transferul între diferitele moduri de funcționare s-a realizat cu ajutorul unui

automat pe stare implementat în motorul grafic XNA.

29
 Figura 4.1.2 - Automatul de stare implementat

4.2 Stocarea datelor

Programul prezentat dispune de o bază de date formată din fișiere Excel ce

stochează datele unui gest sau a unei poziții. Aceste documente sunt create atunci când
aplicația este nou instalată și pornită pe un PC. Există și o bază de date predefinită prin
care utilizatorul poate compune anumite gesturi, aceasta se adaugă în folder-ul
aplicației la instalare automat. Pentru a accesa aceste date, programul necesită ca
sistemul de operare Windows pe care lucrează, să dispună de Office Excel, iar dacă
acesta nu este instalat, aplicația va avertiza utilizatorul în legatură cu această
problemă. Avantajul utilizării unui sistem de stocare a datelor pe Microsoft Excel este
acela de a permite o comunicare mult mai bună între kinetoterapeut și pacient. Având
în vedere faptul că aplicația dispune de mai multe moduri de funcționare precum
modul de învățare și modul de asistență pacient, aceasta poate fi folosită atât în
cabinetul fizioterapeutului pentru a învăța sistemul să recunoască anumite gesturi, cât
și de pacient acasă utilizând modul asistență. Așadar atunci când un personal calificat
va termina de executat gesturile dorite, pentru fiecare pacient în parte, acesta poate
trimite fișierul cu gesturile învățate, necesare pentru o anumită perioadă de timp, către
pacient chiar și prin e-mail. La rândul său, pacientul descarcă fișierul prescris și îl
încarcă în folder-ul aplicației, astfel la următoarea pornire a programului acesta poate
începe exercițiile. Pe lângă avantajele prezentate mai sus, de menționat cum citirea din
fișier se realizează cu ajutorul unui algoritm particularizat pe formatul fișierului și nu
prin interogări SQL precum în cazul utilizării unui sistem de baze de date precum
Microsoft SQL.

30
4.3 Interfața modurilor de funcționare

În funcție de starea de funcționare aleasă, utilizatorul are posibilități diferite de

acționare asupra programului. Modul 1, “Gesture Learning” oferă următoarele acțiuni
precum în figura 4.3.1.

Figura 4.3.1 - Meniul de învațare poziții/gesturi

Meniul “Pose Learning” permite învățarea unei poziții. La apăsarea butonului

“Learn a new pose” se va declanșa un timer ce va număra timp de 8 secunde. La fiecare
secundă un chenar de avertizare își schimbă culoarea din verde în roșu, respectiv
invers. În acest timp subiectul urmărit de Kinect are timp pentru a se poziționa în
poziția dorită. În urma terminării celor 8 secunde, chenarul își schimbă culoarea în
galben și realizează achiziția, calculează poziția de referință precum în capitolul 3, și
pe lângă acest pas, înregistrează și coordonatele 3D (neprelucrate) în spațiul Kinect
pentru a fi folosite în exemplificarea pozițiilor atunci când se doreste învățarea uneia
noi, pentru a se evita repetarea acestora. Butonul listă din dreapta butonului “Learn a
new pose”, are rolul de a afișa pozițiile învățate pentru a fi vizionate în cazul în care
se dorește acest lucru.

Meniul “Gesture learning” funcționează similar cu cel prezentat anterior însă se

vor memora 32 de poziții eșantionate la 200 ms distanță între achiziții. În cele 8 secunde
de pregătire subiectul are timp să se poziționeze în poziția de start, atunci când
semnalul luminos ramane galben, pe ecran se afișează numărul achiziției, iar de atunci
se poate începe mișcarea ce se dorește a fi învățată. La finalul achiziției celor 32 de

31
cadre, sistemul va întreba utilizatorul dacă dorește salvarea temporală a acestora sau
realizarea unei noi achiziții. Răspunsul trebuie oferit verbal, “save” pentru a îl salva
temporal și “delete” pentru realizarea unei noi achiziții. După ce se realizează salvarea
temporală atunci se poate denumi gestul și în urma apăsării butonului save gesture,
acesta este salvat permanent în baza de date și poate fi imediat recunoscut.

Meniul “Learn a step-by-step gesture” este similar cu cel precedent însă la

activarea acestuia nu se mai efectuează 32 de achiziții ci atâtea câte dorește utilizatorul.
După cele 8 secunde de pregătire a achiziției sistemul va întreba utilizatorul dacă
dorește să continue completarea gestului cu o poziție, confirmarea trebuie realizată și
aici verbal pentru ca subiectul să nu fie nevoit să se deplaseze până la calculator și
înapoi în locul unde a realizat și achizițiile precedente, deoarece pot exista date eronate
ce sunt trimise drept referință.

Ultimul meniu disponibil “Create a gesture with predefined poses” presupune

compunerea unui gest cu ajutorul unor poziții deja existente în sistem. Utilizatorul are
control asupra pozițiilor adăugate și le poate șterge pe cele considerate nepotrivite în
urma compunerii gestului. Pentru a putea viziona pozițiile de care dispune sistemul,
butonul “V” permite vizualizarea poziției pe ecran utilizând coordonatele din spațiul
Kinect, salvate în momentul apasării unuia dintre butoanele de save. Acestea sunt
preluate de motorul grafic, se deconectează updatarea în timp real a manechinului și
se consideră doar coordonatele salvate drept update pentru pozițiile încheieturilor
manechinului.

După cum se poate observa fiecare meniu are un buton “V” ce ajută la
vizualizarea gesturilor deja existente sau a pozițiilor pentru a se evita repetarea
acestora.

Modul 2 “User supervisor” dispune de o interfață intuitivă ce impune trecerea de la

stânga la dreapta a mouse-ului pentru selectarea exercițiilor. Pentru a afişa interfaţa
este necesară apăsarea butonului click dreapta, deoarece aplicaţia porneşte în mod
obişnuit cu aceasta ascunsă. Deasemenea se poate ascunde interfaţa şi în timpul
funcţionării în cazul în care se doreşte o vizualizare mai mare a modelului grafic
pentru o mai bună întelegere a exerciţiilor.

Figura 4.3.2 - Meniul de selectare al exercițiilor și al modului de recunoaștere

Având în vedere că există două modalități de recunoaștere precum au fost

prezentate în capitolul 3, amestecarea gesturilor de la cei doi algoritmi de recunoaștere
nu este permisă deoarece rezultatele nu ar fi conform așteptărilor. Astfel înainte de
adăugarea exercițiilor, utilizatorul este obligat să aleagă un mod de recunoaștere.

32
Selectarea algoritmului de recunoaștere se face prin bifarea unei casuțe din sub-meniul
“Recognition Mode”.

După aceea, se pot adăuga exercițiile recomandate de către un fizioterapeut.

Butoanele “Preview” permit exemplificarea exercițiului de către un model 3D. Înainte
de a se adăuga un gest, se va selecta și de câte ori se dorește execuția unui exercițiu.
Butonul “+” adaugă exercițiul în lista ce va fi pasată algoritmului de recunoaștere.
Butoanele “+” sunt inactive atâta timp cât nu este selectat un mod de recunoaștere.
După ce se selectează un algoritm, se va activa butonul “+” corespunzător pentru a
permite adăugarea acestora în listă.

Și în meniul “Selected exercises for practice” se oferă libertate deplină

utilizatorului, acesta poate parsa lista de exerciții la stânga și la dreapta pentru a
verifica încă odată înainte de start ce s-a adăugat. Bineînteles se poate șterge un
exercițiu prin apăsarea butonului “Delete from the list of exercises”.

Pentru a se începe exercițiile, apăsarea butonului “Start this list of exercises”

va prelua lista ce conține numele exercițiilor ce trebuiesc efectuate, și se trimit către
obiectul ce conține algoritmul ales. Înainte de a se trimite implicit această listă,
programul va exclude restul gesturilor din baza de date și le va lua în considerare doar
pe cele trimise pentru a se evita o procesare intensă respectiv o solicitare inutilă a
procesorului. La apăsarea butonului “Stop this list of exercises” sistemul intră în
pauză, se oprește algoritmul, însă lista nu se va șterge, decât atunci când dorește acest
lucru utilizatorul sau exercițiile au fost efectuate complet. Tot pentru a nu se solicita
procesorul, atunci când nu se doreste identificarea unei poziții sau a unui gest, nu se
va executa nici un algoritm de recunoaștere.

4.4 Analiza similaritudinii între două poziții

În meniul de învățare a pozițiilor pentru a eficientiza utilizarea algoritmului de

recunoaștere a unui gest folosind algoritmul de identificare static, s-a implementat o
modalitate de verificare a similaritudinii între două poziții (metrici de referință).

Recunoașterea este procesul de etichetare și clasificare a două obiecte. Un model este

format dintr-o serie de obiecte ce au anumite trăsături ce le caracterizează. Fiecare
obiect este reprezentat printr-un vector de trăsături într-un spațiu cu k dimensiuni ,
𝑋𝑓 = 𝑋𝑓1 𝑥𝑋𝑓2 𝑥 … 𝑥 𝑋𝑓𝑘 pentru o descriere a obiectelor cu ajutorul vectorului de
trăsături 𝑓 = [𝑓1 𝑓2 … 𝑓𝑘 ]𝑇 , 𝑋𝑓𝑖 este domeniul de valori pentru trăsătura 𝑓𝑖 . Un obiect
este un punct în spațiul trăsăturilor 𝑋𝑓 , 𝑋𝑓 este un subspațiu al lui 𝑅 𝑘 , k este numărul
de trăsături necesare pentru descrierea obiectului. Pentru a putea realiza această
analiză corect este foarte important alegerea trăsăturilor ce vor fi luate în considerare.

Pentru alegerea setului minimal de trăsături trebuiesc respectate următoarele

condiții:

33
  Independență, o schimbare a valorii unei trăsături nu trebuie să afecteze
semnificativ valoarea altei trăsături din setul ales
 Robustețe, fiecare trăsătura a unui obiect trebuie să fie invariantă la operații ca
translația, rotația sau scalarea
 Discriminantă, fiecare trăsătură trebuie să aibă valori semnificativ diferite
pentru fiecare clasă de obiecte
 Consistență, fiecare trăsătură trebuie să aibă aceeași valoare pentru obiectele ce
formează o clasă

Pentru mai mule clase de obiecte, selectarea trăsăturilor este realizată ţinând cont
de eficacitatea acestora în procesul de separare a claselor. Având în vedere că se va
folosi acest algoritm doar în situația în care utilizatorul compune un gest cu ajutorul
pozițiilor predefinite, nu se vor defini clase de obiecte, în schimb se va analiza o poziție
nouă adăugată cu fiecare deja existentă în listă.

Calculul distanțelor între două poziții (puncte, definite prin trăsăturile unui obiect)
s-a realizat folosind următoarele metrici:

 Euclid:

k
d (x, μ p )   ( i ( xi   pi )) 2
2
(4.4.1)
i 1

 Chebychev:

d (x, μ p )  max  i ( xi   pi ) (4.4.2)

1i  k

Euclid și Chebychev sunt variante scalate ale metricilor Euclid și Chebychev.

Scalarea este realizată utilizând minimul (𝑚𝑖 ) și maximul (𝑀𝑖 ) valorilor pentru
trăsătura i, considerând toate obiectele (pozițiile predefinite). Factorul de scalare este
dat de relația următoare:

 𝑖 = 1/(𝑀𝑖 − 𝑚𝑖 ) (4.4.3)

Trăsăturile alese pentru cazul prezentat au fost unghiurile prezentate în

Capitolul 3, formula 3.5. Acestea se adună și rezultatul definește trăsătura unui
segment. Împreună toate unghiurile fiecărui segment de interes definesc caracteristica
unei poziții. Atunci când utilizatorul adaugă o poziție nouă în listă se verifică distanța
dintre aceasta și fiecare poziție deja existentă folosind formula 4.4.1, 4.4.2 respectiv
4.4.3. Rezultatul este o valoare de tip double ce reprezintă cât de apropriate sunt două
34
poziții. Dacă rezultatul este 0 atunci pozițiile sunt identice, iar dacă valoarea se află în
intervalul 1 – 10 atunci se va semnala utilizatorului că poziția nou adaugată poate fi
confundată în procesul de recunoaștere prezentat în capitolul 3.

Această analiză este esenţială atunci când se doreşte recunoaşterea unui gest
folosind algoritmul prezentat în secţiunea (3.4.2) deoarece exclude posibilitatea de a
identifica o poziţie nedorită înaintea uneia esenţiale în lista de poziţii analizată
reducând astfel şi efortul de procesare.

Având modalitatea de mai sus prezentată de identificare a similaritudinii între

două poziții, analiza poate fi exstinsă pentru a analiza similaritudinea între două
gesturi, reducând astfel un efort de procesare și mai mare în algoritmul DTW. Deși
metricile prezentate sunt folosite în recunoaștere de imagine, algoritmul se pretează
foarte bine și pentru recunoașterea unei poziții datorită trasăturilor alese
corespunzător.

35
5.Integrarea sistemului în diverse aplicații

Aplicația așa cum am prezentat și în capitolul introducere dispune de mai

multe funcționalități și se poate integra foarte ușor într-un sistem de control al unei
case inteligente. Microsoft Kinect poate fi amplasat în interiorul unei camere astfel
încât să capteze un spațiu cât mai amplu. Conectarea acestuia la o unitate de procesare
poate ridica anumite probleme în amenanjarea spațiului însă această problemă se
poate soluționa utilizând noua gamă de computere, numite mini-computers
dezvoltate de marii producători de componente IT (Gygabyte, Asus, ASRock). Aceste
unități ocupă puțin spațiu (L=4”, l=4”, h=2,54”) și oferă performanțe asemănatoare
Desktop-urilor. Un alt aspect important de menţionat este preţul acestor mini-unităţi
comparativ cu cele clasice. Acestea pot varia între 300 $ respectiv 380 $ faţă de preţul
unei unităţi convenţionale 400 $ - 500 $, luând în calcul aceleaşi performanţe.

Figura 5.1 - Unitatea de procesare ce rulează aplicația și primește date din

partea Kinectului

Unitatea din figura 5.1 trebuie să dispună de o rețea locală folosită în incinta
casei căreia se dorește automatizarea. Pe o altă unitate de procesare sau chiar pe cea
care rulează aplicația prezentată, se instalează un program server, precum cel din
figura 5.2 ce primește diferite variabile de tip “string”. Aceste variabile recepționate,
sunt interpretate de către program și în funcție de setări, generează o anumită
comandă pentru a acționa diferite elemente de execuție instalate în perimetrul casei.
Programul server este scris tot în limbajul C#, iar împreună întreg sistemul necesită
36
utilizarea unui sistem de operare Windows. Server-ul este configurat cu ip-ul localhost
(127.0.0.1).

Figura 5.2 - Programul server ce recepționează datele selectate pentru a fi trimise de

aplicație atunci când se recunoaște o poziție

Serverul deține o evidență a comenzilor, legat de data și ora la care acestea au

fost recepționate, precum și numărul de conexiuni, deoarece pot exista mai multe
dispozitive Kinect amplasate în camere diferite. Prelucrarea datelor se realizează pe
server imediat ce acestea au fost recepționate. După cum se poate observa în figura
5.2, utilizatorul aplicației poate configura după instalarea acesteia poziția ce dorește să
fie asociată cu o anumită comandă trimisă catre server. Acesta dispune de 33 de poziții
predefinite, alături de 6 comenzi posibile. Asocierea este limitată la 2 configurații fiind
o prezentare a utilizării Kinectului și în alte domenii de activitate, însă această limită
poate fi modificată programatic foarte ușor.

Interfața modului de funcționare “User Commands” este foarte simplă și ușor

de utilizat, configurația realizându-se în chenarul din stânga.

Figura 5.3 - Interfața “User Commands”

Atunci când se selectează o poziție și o acțiune asociată acesteia se salvează

automat după selectare în fișier configurația dorită. La schimbarea unei poziții sau a
unei acțiuni se suprascrie în document noua configurație, așadar în cazul unei pene de
37
curent, atunci când sistemul repornește setările să fie conform cerințelor utilizatorului.
Chenarul roșu din dreapta este folosit pentru debugging, atunci când se dorește o
testare a programului. Acesta se colorează în verde atunci când se recunoaște gestul
de atenționare “COMMAND” a sistemului că utilizatorul urmează să se poziționeze
pentru a îi fi interpretată comanda. După ce trece timpul de așteptare (1 secundă)
pentru captarea poziției, chenarul se colorează roșu, semnalând astfel că utilizatorul
nu dorește a oferi o comandă. În acest mod se poate observa cum se îmbină utilizarea
modului de recunoaștere dinamic (DTW – 3.4.1) cu cel static 3.2 pentru a putea
controla confortul casei fară a utiliza una din metodele clasice de interacțiune precum:
comenzi vocale, telecomandă sau smartphone.

Butonul “v” este adăugat precum și în celelalte moduri de funcționare pentru a

îi oferi utilizatorului posibilitatea de a vizualiza poziția care se dorește a fi asociată
unei comenzi. Conexiunea la server se realizează atunci când se intră în modul “User
Commands” cu ajutorul implementării automatului de stare ce suportă 3 tipuri de
acțiuni: entry action, update action și exit action. Entry action se execută atunci când se
intră într-un mod de funcționare, fiecare mod necesită diferite acțiuni respectiv
validări pentru a putea funcționa corect, update action se execută atâta timp cât
programul rulează una din stările prezentate în figura 4.3 iar exit action atunci când se
iese dintr-o stare și se dorește eliberarea memoriei eventual salvarea anumitor date. În
cazul “User Commands” se dorește a se realiza conexiunea la server într-o acțiune de
tip entry action. În cazul în care server-ul este oprit sau nu se poate efectua conectarea
clientului la acesta, utilizatorul va fi anunțat printr-un mesaj precum cel din figura 5.3
“Server is not online”. În cazul în care există mai multe dispozitive Kinect, verificarea
stării acestora se poate verifica direct din server, cu ajutorul anumitor comenzi ce se
transmit pe rețea se poate diagnostica fiecare dispozitiv. Comenzile ce se pot apela
fiind următoarele:

1. getStatusAll – returnează setarile poziție – acțiune impreună cu

parametrii algoritmilor de recunoaștere a fiecărui Kinect
2. stopCommands x – oprește recunoașterea pozițiilor Kinect-ului cu
numărul x
3. startCommands x – pornește recunoașterea pozițiilor Kinect-ului cu
numărul x

Acesta este doar un exemplu de integrare a sistemului Computer – MS Kinect

în afară de cel medical, iar costul implementării unui asemenea sistem de management
al unei case inteligente este accesibil iar efortul implementării este scăzut.

38
6.Rezultate experimentale și concluzii

6.1 Rezultate experimentale

Deoarece aplicația dispune de două metode de identificare a gesturilor diferite

am analizat rata de succes a recunoașterii fiecărui algoritm în parte utilizând aceleași
gesturi învățate cu cele două moduri diferite de învățare disponibile.

Așadar au fost selectate 4 gesturi, precum se pot observa în figurile din tabelul 6.1.

Exercițiul selectat Rata succes utilizând algoritmul Rata succes utilizând algoritmul
DTW SBS
Denumire exercițiu: Exercise1 Denumire exercițiu: Exercise1-
sbs

Rata de succes în identificare Rata de succes în identificare:

100% 90%

(Pentru stabilirea ratei de succes s-au (Pentru stabilirea ratei de succes

executat 10 replici ale gesturilor s-au executat 10 replici ale
prezentate și s-a numărat de câte ori gesturilor prezentate și s-a
algoritmul a identificat gestul.) numărat de câte ori algoritmul a
identificat gestul.)

Denumire exercițiu: Exercise2 Denumire exercițiu: Exercise2-

sbs

Rata de succes în identificare: Rata de succes în identificare:

90% 60%

(Pentru stabilirea ratei de success s- (Pentru stabilirea ratei de

au executat 10 replici ale gesturilor success s-au executat 10 replici
prezentate și s-a numărat de câte ori ale gesturilor prezentate și s-a
algoritmul a identificat gestul.) numărat de câte ori algoritmul a
identificat gestul.)

39
 Denumire exercițiu : Exercise3 Denumire exercițiu: Exercise3-
sbs

Rata de succes în identificare: Rata de succes în identificare:

100% 70%

(Pentru stabilirea ratei de success s- (Pentru stabilirea ratei de

au executat 10 replici ale gesturilor success s-au executat 10 replici
prezentate și s-a numărat de câte ori ale gesturilor prezentate și s-a
algoritmul a identificat gestul.) numărat de câte ori algoritmul a
identificat gestul.)

Denumire exercițiu:
Predefined1

-Nu se poate identifica utilizând

algoritmul DTW deoarece gestul a
fost compus cu ajutorul pozițiilor
predefinite
Rata de succes în identificare:
100%
(Pentru stabilirea ratei de
success s-au executat 10 replici
ale gesturilor prezentate și s-a
numărat de câte ori algoritmul a
identificat gestul.)

Denumire exercițiu:
Predefined2

-Nu se poate identifica utilizând

algoritmul DTW deoarece gestul a Rata de success în identificare:
fost compus cu ajutorul pozițiilor 80%
predefinite

(Pentru stabilirea ratei de

success s-au executat 10 replici
ale gesturilor prezentate și s-a
numărat de câte ori algoritmul a
identificat gestul.)

Tabelul 6.1 - Prezentarea gesturilor alese pentru rezultate

Din tabelul 6.1 se poate observa o performanță foarte bună a algoritmului SBS
deși nu este la fel de performant precum DTW, acesta oferă rate de succes
satisfăcătoare. S-au adăugat în tabel, două gesturi formate cu ajutorul pozițiilor
predefinite iar acestea nu pot fi identificate cu ajutorul algoritmului DTW deoarece
sunt compuse din puține poziții, însă algoritmul SBS le-a identificat cu o rată de succes
mulțumitoare.

În continuare se va prezenta rata de succes în identificarea pozițiilor cu ajutorul

tabelului 6.2. Este foarte importantă verificarea rezultatelor identificării statice,

40
deoarece capitolul 5 folosește algoritmul de identificare dinamică 3.4.1 cu cel de
identificare statică 3.2.

Poziție Nume, Rata de succes în identificare

Nume poziție predefinită: P3

Rata de succes : 70%

(Pentru stabilirea ratei de success s-au executat 10

replici ale pozițiilor prezentate și s-a numărat de câte
ori algoritmul a identificat poziția.)

Nume poziție predefinită: P3

Rata de succes : 100%

(Pentru stabilirea ratei de success s-au executat 10

replici ale pozițiilor prezentate și s-a numărat de câte
ori algoritmul a identificat poziția.)

41
 Nume poziție predefinită: P3

Rata de succes : 90%

(Pentru stabilirea ratei de success s-au executat 10

replici ale pozițiilor prezentate și s-a numărat de câte
ori algoritmul a identificat poziția.)

Nume poziție predefinită: P3

Rata de succes : 60%

(Pentru stabilirea ratei de succes s-au executat 10 replici

ale pozițiilor prezentate și s-a numărat de câte ori
algoritmul a identificat poziția.)

Tabel 6.2 - Poziții selectate pentru rezultate

Algoritmul de identificare a pozițiilor este foarte eficient și rapid în identificare.

Astfel subiectul nu trebuie să aștepte foarte mult atunci când dorește să execute o
comandă. Rata de succes în identificarea pozițiilor fiind satisfăcătoare.
42
 În continuare voi prezenta rezultatele algoritmului 4.4 de identificare a
similaritudinii între două poziții. Acesta este folosit atunci când se compune un gest
cu ajutorul pozițiilor predefinite. După ce sunt mai mult de 2 poziții adăugate în listă,
se va compara poziția nou adăugată cu cele deja existente apoi se va enumera pe ecran
pozițiile care pot fi confundate ușor.

P13, P12, P11, P10,

Poate fi confundată Poate fi confundată Poate fi confundată Poate fi confundată
cu : Nici o poziție cu: cu: cu: P12, P13
Nici o poziție Nici o poziție

Tabel 6.3 - Algoritmul de identificare a similaritudinii între două poziții

Se poate observa în tabelul 6.3 cum poziția P10, în urma analizei prezentate în
secțiunea 4.4, este semnalată ca fiind similară cu P12 respectiv P13. În urma acestui
feedback, utilizatorul poate decide dacă păstrează această poziție în lista ce formează
un gest sau elimină poziția nou adăugată. Având în vedere acest sistem de analiză a
similaritudinii se pot forma gesturi, având siguranța faptului că pozițiile sunt
semnificativ diferite și pot fi identificare ușor de către algoritmul de identificare a
pozițiilor.

6.2 Planuri de viitor

Pentru viitor, se dorește imbunătațirea aplicației, crescând acuratețea în

achiziția datelor folosind Kinect v2, ce raspunde mult mai rapid și mai eficient, astfel
aplicația trebuie rescrisă pentru Microsoft Kinect SDK 2.0. Extinderea și îmbunătățirea
interfeței grafice este un pas absolut necesar pentru a oferi o imagine mai atractivă

43
utilizatorilor, cât și mai ușor de înțeles. Adăugarea unui filmuleț de tip tutorial pentru
persoanele care deschid pentru prima dată aplicația. Se mai dorește scrierea anumitor
funcționalități pe fire de execuție separate pentru a nu se bloca în anumite situații,
precum atunci când se realizează scrierea în document sau citirea datelor. Deasemenea
implementarea unui sistem de evidență a progresului acumulat de pacient și
raportarea automată către personalul calificat cu rezultatele înregistrate este necesar
pentru o comunicare mai ușoară între pacient și fizioterapeut.

Pentru a extinde utilizarea unui asemenea sistem, ar fi benefică scrierea

aplicației și pentru platformele Xbox. Astfel pacientul s-ar putea folosi direct de
platforma de jocuri pentru realizarea exercițiilor.

6.3 Concluzii

Sistemul prezentat Microsoft Kinect – PC se dovedește a fi un asistent personal

inteligent, ușor de folosit. Deși nu este capabil să recunoască poziții la orizontală,
deoarece nu acesta a fost scopul senzorului, este foarte fiabil în recunoașterea
gesturilor și a pozițiilor în poziția șezut respectiv drepți. Acest lucru se poate deduce
în urma analizelor rezultatelor efectuate în secțiunea 6.1, obținând atât pentru gesturi
cât și pentru poziții rate de succes satisfăcătoare. Aplicația dispune de algoritmi
performanți ce consumă resurse hardware însă datorită implementării unui mecanism
de optimizare a datelor prelucrate se reduce efortul de calcul semnificativ.
Tehnologiile folosite fiind oferite gratis pentru studenți (Visual Studio, 3DS Max)
respectiv open source (Digital Rune).

Fiind foarte ușor de implementat un asemenea sistem, integrarea acestuia

pentru diverse activități în afara ariei medicale se dovedește a fi un succes. În prezenta
lucrare s-a prezentat utilizarea Microsoft Kinect doar în două activități, medicale
respectiv automatizarea unei case, însă aplicațiile acestuia prezentate în diferite
documente de specialitate cât și pe internet depașesc cu mult pragul inițial impus
pentru acesta și anume de controller pentru jocuri Xbox. Pentru toate aceste aplicații
trebuie implementat un algoritm de recunoaștere a gesturilor respectiv al pozițiilor.
Cei mai folosiți algoritmi de recunoaștere a gesturilor fiind Dynamic Time Warping
prezentat și în această lucrare însă se mai preferă și Hidden Markov Model. Pe lângă
algoritmul Dynamic Time Warping s-a implementat și un algoritm personal de
recunoaștere a gesturilor bazat pe identificarea fiecărei poziții în parte, obținând
rezultate foarte bune în urma testelor.

De precizat faptul că pentru pacienți ce au suferit atacuri cerebrale minore sau

chiar medii, există foarte multe exerciții kinetoterapeutice ce se pretează foarte bine la
un asemenea sistem. Exercițiile selectate pentru testare au fost preluate de pe site-ul:
https://www.physiotherapyexercises.com/

44
Bibliografie

1. Europe Population Age Distribution , Accesat la data: 14.01.2016

http://ec.europa.eu/eurostat/statistics-
explained/index.php/Population_structure_and_ageing
2. Chuan-Jun Su, 2013, Personal Rehabilitation Exercise Assistant with Kinect
and Dynamic Time Warping, International Journal of Information end
Education Technology, Vol.3, no. 4
3. Aleksandar Rodic, Doina Pisla, Hannes Bleuler, 2014, New Trends in Medical
and Service Robots, Research Center for Industrial Robots Simulation and
Testing
4. Jr Ding, Che-Wei Chang, 2014, An eigenspace-based method with a user
adaptation scheme for human gesture recognition by using Kinect 3D data,
Department of Electrical Engineering - National Formosa University
5. Silvia Anton, Florin Daniel Anton, 2015, Monitoring Rehabilitation Exercises
using MS Kinect, The 5th IEEE International Conference on E-Health and
Bioengineering – EHB 2015
6. Kinect for Windows Sensor Components and Specifications, Accessat la data:
26.03.2016, https://msdn.microsoft.com/en-us/library/jj131033.aspx
7. John MacCormik , How does the Kinect Work?, Accesat la data: 3.04.2016,
https://courses.engr.illinois.edu/cs498dh/fa2011/lectures/Lecture/2025/20-
/20How/20the/20Kinect/20Works/20-/20CP/20Fall/202011.pdf
8. Kourosh Khashelham, Sander Oude Elberink, 2012, Accuracy and Resolution
of Kinect Depth Data for Indoor Mapping Applications, Accesat la data:
27.03.2016, http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3304120/
9. Jan Smisek, Michal Jancosek, Tomas Pajdla, 3D with Kinect, Department of
Cybernetics, FEE, Czech Technical University in Prague

10. Crawford, 2010 , Accesat la data: 4 3, 2016, de pe electronics.howstuffworks:

http://electronics.howstuffworks.com/microsoft-kinect3.htm

11. The University Of Edinburgh , School of Informatics. (2006, 2 2). On-Line

Compendium of Computer Vision:
http://homepages.inf.ed.ac.uk/rbf/CVonline/LOCAL_COPIES/TUZEL1/MeanS
hift.pdf

12. Samiul Monir, S. R. (2012). Rotation and Scale Invariant Posture Recognition.
(pp. 3-5). Research Gate.

13. Muller,M. (2007), Dynamic Time Warping ,Springer

45
46