Tekst źródłowy strony Nowe technologie w fizyce biomedycznej/Posturografia

=Posturograf =

Zajęcia warsztatowe składające się z wprowadzającego w tematykę zajęć wykładu i indywidualnych ćwiczeń wykonywanych przez studentów. Studenci w czasie zajęć przeprowadzają standardowe pomiary posturograficzne, a następnie analizują zebrane dane.

==Plan zajęć==

Zajęcia 1:
*Wstęp teoretyczny:
**Wii Balance Board (budowa, główne biblioteki obsługujące sensor, zastosowania)
**Projesjonalne systemy do rejestracji siły nacisku
**Równowaga a stabilność posturalna
**Podstawowe zadania posturograficzne
**Opis wybranych wskaźników do zadań posturograficznych
*Wprowadzenie do pomiarów przeprowadzanych na zajęciach (zapoznanie się z wybranymi scenariuszami oraz modułami do analizy)
*Zapoznanie się z działaniem Wii Balance Board
*Przeprowadzenie pomiarów

[[Media: WiiBoard.pdf]] Informacje wstępne oraz opis zadań

[[Media: WiiBoardENG.pdf]] Introduction and task description in English
<!--
[[Media:wprowadzenie.pdf]] Wykład z zajęć wprowadzających
[[Media:Pomiary_wii.pdf]] Wstęp do pomiarów posturograficznych
-->

Zajęcia 2,3,4:
*Analiza zebranych danych
*Prezentacja wyników

==Pomiary==
Pomiary przeprowadzane są w środowisku OpenBCI przy użyciu aplikacji Brain4edu (na Ubuntu 16.04). Opis architektury systemu OpenBCI oraz podręcznik użytkownika Brain4edu dostępne są na stronie http://laboratorium-eeg.braintech.pl/. Z samego OpenBCI można również korzystać na systemie Windows -> instrukcja [[Media: obci_Windows.pdf]]. 

Zaczynamy od uruchomienia aplikacji Brain. W prawym górnym rogu ekranu pojawi się ikona mózgu będąca interfejsem graficznym aplikacji. Do pomiarów posturograficznych wybieramy opcję 'Wii App', która otworzy okno z wyborem scenariuszy.

[[Plik:brain4edu.png|300px|thumb|left|<figure id="fig:wbb"></figure>Interfejs graficzny aplikacji Brain4edu]]
[[Plik:wiiApp.png|300px|thumb|right|<figure id="fig:wbb"></figure>Okno wyboru scenariuszy eksperymentalnych aplikacji WiiApp]]

<!--
Pomiary przeprowadzane są w środowisku OpenBCI. Architektura systemu oraz opis wybranych scenariuszy jest dostępny na stronie http://bci.fuw.edu.pl/wiki/Tutorials.  Szczegółowe informacje dotyczące konfiguracji OpenBCI na Ubuntu 14.04 LTS można znaleźć pod adresem http://deb.braintech.pl/. Po zainstalowaniu pakietów źródła znajdą sie w katalogu <tt>/usr/share/openbci</tt>.

Z OpenBCI można również korzystać na systemie Windows -> instrukcja [[Media: obci_Windows.pdf]]

Rejestracja danych odbywa się w środowisku OpenBCI. System ten uruchamiamy wykonując w terminalu polecenie: 
<source lang="c">$ obci_gui --presets new_tech </source>
-->

Podczas zajęć przeprowadzone zostaną następujące pomiary:
*stanie swobodne z oczami otwartymi/zamkniętymi,
*wychylenia szybkie i "z przytrzymaniem" bez informacji zwrotnej dla badanego (w przód, w tył, w prawo, w lewo),
*wychylenia szybkie i "z przytrzymaniem" z informacją zwrotną dla badanego (w przód, w tył, w prawo, w lewo).

W wyniku każdego pomiaru otrzymujemy komplet trzech plików (domyślna lokalizacja to Katalog Domowy): 
* Plik z sygnałem (.raw) zapisanym w formacie binarnym. W pliku znajdują się próbki z pięciu kanałów – wartości z czterech czujników WBB oraz momenty w czasie (w sekundach) mierzone względem pojawienia się pierwszej próbki.
* Plik z metadanymi (.xml), w którym znajdują się szczegółowe informacje dotyczące rejestracji (nazwy kanałów, częstość próbkowania, całkowita liczba próbek itp.).
* Plik ze znacznikami (.tag), w którym zapisywane są momenty kolejnych zdarzeń (np. początek i koniec wykonywania zadania) zsynchronizowane z sygnałem. Każdy znacznik posiada charakterystyczną nazwę, moment wystąpienia w sygnale, długość oraz ewentualnie opis. 
<!--W przypadku zadań z informacją zwrotną dla badanego generowane są dwa pliki ze znacznikami. Interesujące nas informacje znajdują się w pliku z rozszerzeniem .game.tag.-->

==Analiza danych==

===Przygotowanie danych do analizy===
Pierwszym etapem analizy jest wczytanie danych. Korzystamy tutaj z funkcji klasy ReadManager. Otrzymany obiekt posiadaja metodę 'get_samples', która zwraca macierz 5-kanałową. Pierwsze 4 kanały to dane z kolejnych sensorów (górny lewy-TL, górny prawy-TR, dolny prawy-BR, dolny lewy-BL), natomiast 5 kanał to próbki czasu wyrażone w [s].

<source lang="Python">
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from obci.signal_processing import read_manager
from obci.signal_processing.balance.wii_preprocessing import *
from obci.signal_processing.balance.wii_analysis import *

file_name = 'still_eyes_closed_eyes_open'
wbr = read_manager.ReadManager(file_name+'.obci.xml', file_name+'.obci.raw', file_name + '.obci.tag')
TL = wbr.get_samples()[0,:]
TR = wbr.get_samples()[1,:]
BR = wbr.get_samples()[2,:]
BL = wbr.get_samples()[3,:]
TIME = wbr.get_samples()[4,:]

</source>

Jednak w przypadku niektórych zadań należy jeszcze przed pobraniem próbek, odpowiednio wyciąć interesujące nas dane względem znaczników. Czynność tę wykonuje funkcja 'wii_cut_fragments' przyjmująca obiekt klasy ReadManager i znaczniki początkowe i końcowe, a zwracająca listę obiektów 'smart_tags'. Liczba tych obiektów odpowiada liczbie zdarzeń z danym znacznikiem (dla stania swobodnego lista będzie miała tylko jeden element, natomiast dla wielokrotnych wychyleń będzie ich kilka). Każdy element na tej liście, również posiada metodę 'get_samples'.

<source lang="Python">
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from obci.signal_processing import read_manager
from obci.signal_processing.balance.wii_preprocessing import *
from obci.signal_processing.balance.wii_analysis import *

file_name = 'still_eyes_closed_eyes_open'
wbr = read_manager.ReadManager(file_name+'.obci.xml', file_name+'.obci.raw', file_name + '.obci.tag')
smart_tags = wii_cut_fragments(wbr, start_tag_name='ss_start', end_tags_names=['ss_stop'])
TL = smart_tags[0].get_samples()[0,:]
TR = smart_tags[0].get_samples()[1,:]
BR = smart_tags[0].get_samples()[2,:]
BL = smart_tags[0].get_samples()[3,:]

</source>

Na podstawie danch z czterech czujników można wyznaczyć wartości wychyleń w kierunkach x i y  (<xr id="fig:wbb">rys. %i</xr>).:

<div style="text-align: center;">
<math>x=\frac{(TR+BR)-(TL+BL)}{TR+TL+BL+BR}</math>

<math>y=\frac{(TR+TL)-(BR+BL)}{TR+TL+BL+BR}</math>
</div>

Należy pamiętać, że dane z czujników pochodzą z układu odniesienia deski Wii Board - zatem uzyskane wartości x i y mieszczą się w zakresie od -1 do 1. Aby uzyskać dane w cm trzeba przemnożyć współrzędne x i y przez odpowiednie czynniki:
[[Plik:wbb_axes.png|600px|thumb|center|<figure id="fig:wbb"></figure>Wii Balance Board z oznaczonymi płaszczyznami ML i AP. TR, TL, BR, BL ozanczają pozycje czterech czujników.]]

Znaczniki 'start_tag_name' oraz 'end_tags_names' dla poszczególnych pomiarów:

* stanie swobodne oczy otwarte: 'ss_start', 'ss_stop'
* stanie swobodne oczy zamknięte: 'ss_eyes_closed_start', 'ss_eyes_closed_stop'

* wychylenia szybkie bez informacji zwrotnej: 'start_fast', 'stop_fast'
* wychylenia "z przytrzymaniem" bez informacji zwrotnej: 'start', 'stop'

* stanie swobodne jako kalibracja do zadań z informacją zwrotną: 'baseline_start', 'baseline_stop'
* wychylenia szybkie z informacją zwrotną: nie ma znaczników - ciągły zapis danych
* wychylenia "z przytrzymaniem" z informacją zwrotną: 'start_1', 'finish'

Dla przypadku wychyleń "z przytrzymaniem" obiekty w liście zwróconej przez funkcję 'wii_cut_fragments' odpowiadają kolejnym realizacjom zadania. Mają one jednak nieco inną strukturę. Oprócz metody 'get_samples()', za pomocą której tak jak poprzednio wczytamy dane z 4 czujników, posiadają również metody:
*'get_end_tag()' - zwraca strukturę, która w polu ['desc']['value'] przechowuje informację o tym czy zadanie zostało wykonane poprawnie (0-niepoprawnie, 1-poprawnie)
*'get_start_tag()' - zwraca strukturę, która w polu ['desc']['value'] przechowuje informację o kierunku wychylenia (pole 'direction', wartości: 'up','down','left','right') oraz o poziomie trudności zadania (pole 'level'). Aby wydobyć informację o kierunku wychylenia (analogicznie dla poziomiu trudności) można skorzystać z funkcji: 
<source lang="Python">
eval(smart_tags[index].get_start_tag()['desc']['value'])['direction']
</source>

Informacje o poziomie trudności, poprawności wykonania zadania oraz kierunku będą potrzebne do podjęcia decyzji, które próby wykonania zadania będą brane do dalszej analizy. Interesują nas jedynie te poprawne o najwyższym poziomie trudności w każdym z kierunków. 

<!--Pierwszym etapem analizy jest wstępne przetworzenie danych. W tym celu należy wyestymować rzeczywistą częstość próbkowania Fs (w idealnym przypadku wynosi ona 65 Hz) oraz przepróbkować sygnał do częstości fs ok. 30 Hz (wychylenia swobodne widoczne są głównie w niższych częstościach).

<source lang="Python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from obci.analysis.balance.wii_read_manager import WBBReadManager
from obci.exps.ventures.analysis import analysis_baseline
from obci.analysis.balance.wii_preprocessing import *
from obci.analysis.balance.wii_analysis import *

def read_file(file_path, file_name, tag_format = 'obci'):
    file_name = file_path+file_name
    wbb_mgr = WBBReadManager(file_name+'.obci.xml', file_name+'.obci.raw', file_name + '.' + tag_format + '.tag')
    return wbb_mgr

FILE_PATH = '/home/newtech/'
FILE_NAME = 'wii_baseline_2015-03-04_15-02-01' #przykładowa nazwa pliku

#wczytanie danych
wbr_baseline = read_file(FILE_PATH, FILE_NAME)
#estymacja częstości próbkowania Fs                                  
Fs = analysis_baseline.estimate_fs(wbr_baseline.mgr.get_channel_samples('TSS')) 
#wpisanie częstości Fs do obiektu
wbr_baseline.mgr.set_param('sampling_frequency', Fs)   
#przepróbkowanie z czynnikiem 2                         
wbr_baseline = wii_downsample_signal(wbr_baseline, factor=2, pre_filter=True, use_filtfilt=True) 
#odczytanie nowej częstości próbkowania fs
fs = float(wbr_baseline.mgr.get_param('sampling_frequency'))                           

</source>

Po takich operacjach dane przechowywane w obiekcie 'wbr_baseline' klasy WBBReadManager są gotowe do użycia. Klasa ta posiada metodę 'get_raw_signal', która zwraca 4-kanałową macierz z danymi z 4 czujników (są to kanały odpowiadające kolejno czujnikom: górny lewy-TL, górny prawy-TR, dolny prawy-BR, dolny lewy-BL). Można wyznaczyć wartości wychyleń w kierunkach x i y na podstawie informacji z czterech czujników (<xr id="fig:wbb">rys. %i</xr>).:

<div style="text-align: center;">
<math>x=\frac{(TR+BR)-(TL+BL)}{TR+TL+BL+BR}</math>

<math>y=\frac{(TR+TL)-(BR+BL)}{TR+TL+BL+BR}</math>
</div>

Należy pamiętać, że dane z czujników pochodzą z układu odniesienia deski Wii Board - zatem uzyskane wartości x i y mieszczą się w zakresie od -1 do 1. Aby uzyskać dane w cm trzeba przemnożyć współrzędne x i y przez odpowiednie czynniki:
[[Plik:wbb_axes.png|600px|thumb|center|<figure id="fig:wbb"></figure>Wii Balance Board z oznaczonymi płaszczyznami ML i AP. TR, TL, BR, BL ozanczają pozycje czterech czujników.]]

Jednak w przypadku niektórych zadań należy jeszcze, przed wyznaczaniem x i y, odpowiednio wyciąć interesujące nas dane względem znaczników. Czynność tę wykonuje funkcja 'wii_cut_fragments', która zwraca listę obiektów 'smart_tags'. Liczba tych obiektów odpowiada liczbie zdarzeń z danym znacznikiem (dla stania swobodnego lista będzie miała tylko jeden element, natomiast dla wielokrotnych wychyleń będzie ich kilka). Każdy element na tej liście, posiada metodę 'get_samples' zwracającą dane w macierzy 7 kanałowej. W pierwszych 4 kanałach znajdują się dane z czujników TL,TR,BR,BL.

<source lang="Python">
smart_tags = wii_cut_fragments(wbr_baseline, start_tag_name='ss_start', end_tags_names=['ss_stop'])
TL = smart_tags[0].get_samples()[0,:]
TR = smart_tags[0].get_samples()[1,:]
BR = smart_tags[0].get_samples()[2,:]
BL = smart_tags[0].get_samples()[3,:]
</source>

Znaczniki 'start_tag_name' oraz 'end_tags_names' dla poszczególnych pomiarów:

* stanie swobodne oczy otwarte: 'ss_start', 'ss_stop'
* stanie swobodne oczy zamknięte: 'ss_oczy_start', 'ss_oczy_stop'

* wychylenia szybkie bez informacji zwrotnej: 'szybkie_start', 'szybkie_stop'
* wychylenia "z przytrzymaniem" bez informacji zwrotnej: 'start', 'stop'

* stanie swobodne jako kalibracja do zadań z informacją zwrotną: 'ss_start', 'ss_stop'
* wychylenia szybkie z informacją zwrotną: nie ma znaczników - ciągły zapis danych
* wychylenia "z przytrzymaniem" z informacją zwrotną: 'start_1', 'finish'

Podczas wczytywania danych z informacją zwrotną interesujące nas informacje znajdują się w pliku z rozszerzeniem .game.tag. Zatem należy ustawić parametr 'tag_format' w wywołaniu funkcji read_file na 'game' (zamiast domyślnie ustawionego 'obci'). Znaczniki czasowe gry nie są zsynchronizowane z sygnałem, ponieważ gra uruchamiana jest w osobnym wątku, który nie ma możliwości komunikacji z multiplekserem. Z tego względu każdy znacznik zapisany w tym pliku posiada czas systemowy, który należy wyrównać względem pierwszej próbki w sygnale. Procedura ta została zaimplementowana w poniższej funkcji, którą należy wykonać przed przepróbkowaniem sygnału:
<source lang="Python">
from obci.exps.ventures.analysis import analysis_helper
wbr_sway.mgr = analysis_helper.set_first_timestamp(wbr_sway.mgr)
</source>
Dalsze kroki przygotowania danych do analizy wykonujemy tak samo. Dla przypadku wychyleń "z przytrzymaniem" obiekty w liście zwróconej przez funkcję 'wii_cut_fragments' odpowiadają kolejnym realizacjom zadania. Mają one jednak nieco inną strukturę. Oprócz metody 'get_samples()', za pomocą której tak jak poprzednio wczytamy dane z 4 czujników, posiadają również metody:
*'get_end_tag()' - zwraca strukturę, która w polu ['desc']['type'] przechowuje informację o tym czy zadanie zostało wykonane poprawnie (0-niepoprawnie, 1-poprawnie)
*'get_start_tag()' - zwraca strukturę, która w polu ['desc']['type'] przechowuje informację o kierunku wychylenia (pole 'direction', wartości: 'up','down','left','right') oraz o poziomie trudności zadania (pole 'level'). Aby wydobyć informację o kierunku wychylenia (analogicznie dla poziomiu trudności) można skorzystać z funkcji: 
<source lang="Python">
eval(smart_tags[index].get_start_tag()['desc']['type'])['direction']
</source>
Informacje o poziomie trudności, poprawności wykonania zadania oraz kierunku będą potrzebne do podjęcia decyzji, które próby wykonania zadania będą brane do dalszej analizy. Interesują nas jedynie te poprawne o najwyższym poziomie trudności w każdym z kierunków. 

-->
<!--Dokumentacja funkcji klasy WBBReadManager (przy pomcy której wczytujemy dane. Korzysta ona z obiektu klasy ReadManager, która została zaprojektowana do wczytywania i segmentacji danych rejestrowanych przy pomocy systemu OpenBCI. Moduł <tt>obci.analysis.balance.wii_preprocessing</tt> umożliwia dodatkowo przepróbkowanie oraz filtrację danych): 

*Przepróbkowanie danych

<source lang="Python">
# Parametry wejściowe:
# wbb_mgr       - obiekt klasy WBBReadManager
# factor        - nowa_fs = fs / factor (int)
# pre_filter    - True/False w zależności czy ma być użyty filtr dolnoprzepustowy z częstością
#                 odcięcia: częstość próbkowania / 2
# use_filtfilt  - True/False w zależności czy ma być użyta procedura 
#                 filtrowania filtfilt/lfilter (bool)

# Funkcja zwraca obiekt klasy WBBReadManager z przepróbkowanym sygnałem.

factor = 2
pre_filter = False
use_filtfilt = True

wbb_mgr = wii_downsample_signal(wbb_mgr, 
                                factor, 
                                pre_factor, 
                                use_filtfilt)
</source>

*Segmentacja danych

<source lang="Python">
# Parametry wejściowe:
# wbb_mgr         - obiekt klasy WBBReadManager,
# start_tag_name  - nazwa znacznika określającego początek fragmentu,
# end_tags_names  - lista z nazwami znaczników określających koniec fragmentu.

# Funkcja zwraca obiekt klasy SmartTagsManager.

smart_tags = wii_cut_fragments(wbb_mgr,
                               start_tag_name='start', 
                               end_tags_names=['stop'])
</source>

*Filtracja danych

<source lang="Python">
# Parametry wejściowe:
# wbb_mgr       - obiekt klasy  WBBReadManager
# cutoff_upper  - częstość odcięcia (float)
# order         - rząd filtru (int)
# use_filtfilt  - True/False w zależności, czy ma być użyta procedura 
#                 filtrowania filtfilt/lfilter (bool)

# Funkcja zwraca obiekt klasy WBBReadManager z przefiltrowanym sygnałem.

cutoff_upper = 20
order = 2
use_filtfilt = False
wbb_mgr = wii_filter_signal(wbb_mgr, 
                            cutoff_upper, 
                            order, 
                            use_filtfilt)
</source> -->

===Analiza danych: stanie swobodne===

W przypadku stania swobodnego z oczami zamkniętymi oraz otwartymi, studenci mają za zadanie wyznaczyć następujące wskaźniki posturograficzne:
<!-- (korzystając z funkcji zaimplentowanych w bibliotece <tt>obci.analysis.balance.wii_analysis</tt>): -->
*położenie środka równowagi COP (''center of posture'')
*maksymalne przemieszczenie względem położenia środka równowagi (w AP,ML oraz przestrzeni AP/ML),
*długość drogi względem położenia środka równowagi (w AP,ML oraz przestrzeni AP/ML),
*średnia prędkość przemieszczenia (w AP,ML oraz przestrzeni AP/ML),
*wskaźnik Romberga - stosunek różnicy długości drogi przy oczach zamkniętych i otwartych, do sumy długości drogi przy oczach zamkniętych i otwartych
<!--*95% powierzchnia ufności elipsy - powierzchnia elipsy, w której powinno zawierać się około 95% punktów drogi COP,
*RMS (''root mean square'') (w AP i ML).--->
Dokładny opis matematyczny wyżej wymienionych wskaźników znajduje się w pracy (Prieto, 1996). 

Należy również przedstawić na wykresie przebieg ruchu COP oddzielnie w płaszczyźnie AP, ML oraz w przestrzeni AP/ML.

Dodatkowo studenci mają za zadanie przeprowadzić analizę rozkładu przestrzennego punktów statokinezjogramu. Statokinezjogramem lub posturogramem nazywamy wędrówkę COP w dwuwymiarowej płaszczyźnie podparcia. Kierunki na tej płaszczyźnie określa się jako AP (y) lub ML (x), przy czym ML oznacza wychylenia w płaszczyźnie czołowej (''medio-lateral''), a AP w płaszczyźnie strzałkowej (''anterio-posterior''). W celu przeprowadzenie takiej analizy, cały zakres zostaje podzielony na jednakowe komórki. Następnie obliczony zostaje histogram przestrzenny czasu przebywania w każdej z nich. Taki histogram pozwala ocenić, czy kontrola położenia referencyjnego COG (''center of gravity''), a tym samym pionowa orientacja ciała, jest prawidłowa. Wyznacznikiem prawidłowej kontroli jest histogram o skupionym rozkładzie i z wyraźnym maksimum. Upośledzenie kontroli objawia się tym, że histogram przestrzenny staje się rozmyty lub wyraźnie niesymetryczny (Błaszczyk, 2004).

===Analiza danych: wychylenia dynamiczne===

Oprócz wskaźników statycznych stabilności do oceny kontroli posturalnej wykorzystuje się również miary dynamiczne. Z punktu widzenia miar bezpośrednich, istotna jest ocena kontroli środka ciężkości ciała w czasie jego świadomego przemieszczania w wyznaczonym kierunku. W ramach pomiarów, studenci mieli za zadanie wykonać dwa rodzaje wychyleń (szybkie i "z przytrzymaniem") w dwóch warunkach: bez informacji zwrotnej dla badanego oraz z informacją zwrotną dla badanego. Dla każdego z przypadków należy wyznaczyć następujące parametry:

*położenie środka równowagi (dla warunku bez informacji zwrotnej będzie to COP ze stania swobodnego z oczami otwartymi, natomiast dla warunku z informacją zwrotną będzie to COP z sesji kalibracyjnej)
*wartość maksymalnego wychylenia (w określonym kierunku) względem położenia równowagi,
*wykresy składowych wychwiań względem położenia równowagi w płaszczyźnie AP, ML w zależności od czasu oraz wypadkowa trajektoria przemieszczeń COP (w dwuwymiarowej przestrzeni AP, ML).

i zbadać czy informacja zwrotna wpływa na rezultaty badanego.

Literatura:
*Błaszczyk J., Biomechanika kliniczna, PZWL, 2004
*Prieto T.E. et al., Measures of postural steadiness: differences between healthy young and elderly adults, IEEE Trans Biomed Eng, 1996, 43(9):956-66
<!--
Przykładowe skrypty do analizy:

*zadanie "stanie swobodne"
<source lang="Python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from obci.analysis.balance.wii_read_manager import WBBReadManager
from obci.analysis.balance.wii_preprocessing import *
from obci.analysis.balance.wii_analysis import *

import matplotlib.pyplot as py

from obci.exps.ventures.analysis import analysis_baseline
from obci.exps.ventures.analysis import analysis_helper

from obci.acquisition import acquisition_helper

FILE_PATH = '~/' #full path
FILE_NAME = 'wii_baseline_2015-03-03_20-51-48' #file name without extension

def read_file(file_path, file_name, tag_format = 'obci'):
    file_name = acquisition_helper.get_file_path(file_path, file_name)
    wbb_mgr = WBBReadManager(file_name+'.obci.xml', file_name+'.obci.raw', file_name + '.' + tag_format + '.tag')
    return wbb_mgr

if __name__ == '__main__':
    #load data
    wbb_mgr = read_file(FILE_PATH, FILE_NAME)

    #add two additional (x, y) channels (computed from sensor values)
    wbb_mgr.get_x()
    wbb_mgr.get_y()

    #estimate true sampling frequency value
    fs = analysis_baseline.estimate_fs(wbb_mgr.mgr.get_channel_samples('TSS'))
    wbb_mgr.mgr.set_param('sampling_frequency', analysis_baseline.estimate_fs(wbb_mgr.mgr.get_channel_samples('TSS')))

    #preprocessing
    wbb_mgr = wii_downsample_signal(wbb_mgr, factor=2, pre_filter=True, use_filtfilt=True)

    #extract fragments from standing task with eyes open
    smart_tags = wii_cut_fragments(wbb_mgr, start_tag_name='ss_start', end_tags_names=['ss_stop'])
    sm_x = smart_tags[0].get_channel_samples('x')
    sm_y = smart_tags[0].get_channel_samples('y')
    py.figure()
    print(wii_COP_path(wbb_mgr, sm_x, sm_y, plot=True))
    py.show()
</source>

*zadanie "wychylenia bez informacji zwrotnej"

<source lang="Python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from obci.analysis.balance.wii_read_manager import WBBReadManager
from obci.analysis.balance.wii_preprocessing import *

from obci.exps.ventures.analysis import analysis_baseline
from obci.exps.ventures.analysis import analysis_helper

from obci.acquisition import acquisition_helper

FILE_PATH_LEFT = '' #full path
FILE_NAME_LEFT = '' #file name without extension

FILE_PATH_RIGHT = '' #full path
FILE_NAME_RIGHT = '' #file name without extension

FILE_PATH_DOWN = '' #full path
FILE_NAME_DOWN = '' #file name without extension

FILE_PATH_UP = '' #full path
FILE_NAME_UP = '' #file name without extension

def read_file(file_path, file_name, tag_format = 'obci'):
    file_name = acquisition_helper.get_file_path(file_path, file_name)
    wbb_mgr = WBBReadManager(file_name+'.obci.xml', file_name+'.obci.raw', file_name + '.' + tag_format + '.tag')
    return wbb_mgr

if __name__ == '__main__':
    #load data from right sway task
    wbb_mgr_right = read_file(FILE_PATH_RIGHT, FILE_NAME_RIGHT)

    #here should be preprocessing... 

    #extract fragments from sway task (right)
    smart_tags_quick = wii_cut_fragments(wbb_mgr_right, start_tag_name='szybkie_start', end_tags_names=['szybkie_stop'])
    x_fragments_quick = [i.get_channel_samples('x') for i in smart_tags_quick]
    y_fragments_quick = [i.get_channel_samples('y') for i in smart_tags_quick]

    #extract fragments from sway&stay task (right)
    smart_tags_long = wii_cut_fragments(wbb_mgr_right, start_tag_name='start', end_tags_names=['stop'])
    x_fragments_long = [i.get_channel_samples('x') for i in smart_tags_long]
    y_fragments_long = [i.get_channel_samples('y') for i in smart_tags_long]
</source>

*zadanie "wychylenia z informacją zwrotną"

<source lang="Python">
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from obci.analysis.balance.wii_read_manager import WBBReadManager
from obci.analysis.balance.wii_preprocessing import *

from obci.exps.ventures.analysis import analysis_baseline
from obci.exps.ventures.analysis import analysis_helper

from obci.acquisition import acquisition_helper

BASELINE_FILE_PATH = '' #full path
BASELINE_FILE_NAME = '' #file name without extension

FILE_PATH = '' #full path
FILE_NAME = '' #file name without extension

def get_baseline_points(file_path, file_name):
    """ baseline area is a rectangle with parameters:
        center point: xc, yc,
        width:        2*xa,
        height:       2*yb.
    """
    xa, ya, xb, yb, xc, yc  = analysis_baseline.calculate(file_path, file_name, show=False)
    return xa, ya, xb, yb, xc, yc

def read_file(file_path, file_name, tag_format = 'game'):
    file_name = acquisition_helper.get_file_path(file_path, file_name)
    wbb_mgr = WBBReadManager(file_name+'.obci.xml', file_name+'.obci.raw', file_name + '.' + tag_format + '.tag')
    return wbb_mgr

if __name__ == '__main__':
    xa, ya, xb, yb, xc, yc = get_baseline_points(BASELINE_FILE_PATH, BASELINE_FILE_NAME)
    wbb_mgr = read_file(FILE_PATH, FILE_NAME)
    wbb_mgr.mgr = analysis_helper.set_first_timestamp(wbb_mgr.mgr) #adjusting tags to signal
</source>

Moduł <tt>obci.analysis.balance.wii_analysis</tt> umożliwia wyznaczenie podstawowych wskaźników posturograficznych z zadania eksperymentalnego "stanie swobodne".

*Maksymalna wartość wychwiań w AP i ML

<source lang="Python">
# Parametry wejściowe:
# x  - macierz reprezentująca kanał x,
# y  - macierz reprezentująca kanał y.

# Funkcja zwraca:
# max_sway  - maksymalne wychwianie (float),
# max_AP    - maksymalne wychwianie w kierunku AP (float), 
# max_ML    - maksymalne wychwianie w kierunku ML (float).

max_sway, max_AP, max_ML = wii_max_sway_AP_MP(x, y)
</source>

*Średnia wartość wychwiań COP od punktu (0,0)

<source lang="Python">
# Parametry wejściowe:
# x  - macierz reprezentująca kanał x,
# y  - macierz reprezentująca kanał y.

# Funkcja zwraca:
# cop         - średnią wartość wychwiań do punktu (0, 0) (float),
# mean_y_COP  - średnią wartość wychwiań do punktu (0, 0) w AP (float),
# mean_x_COP  - średnią wartość wychwiań do punktu (0, 0) w  ML (float).

mean_COP, mean_y_COP, mean_x_COP = wii_mean_COP_sway_AP_ML(x, y)
</source>

*Długość drogi

<source lang="Python">
# Parametry wejściowe:
# wbb_mgr  - obiekt klasy  WBBReadManager,
# x        - macierz reprezentująca kanał x,
# y        - macierz reprezentująca kanał y,
# plot     - True/False (opcjonalnie). 

# Funkcja zwraca:
# path_length    - długość drogi COP (float),
# path_length_x  - długość drogi COP w ML (float),
# path_length_y  - długość drogi COP w AP (float).

path_length, path_length_x, path_length_y = wii_COP_path(wbb_mgr, x, y, plot=False)
</source>

*RMS

<source lang="Python">
# Parametry wejściowe:
# x  - macierz reprezentująca kanał x,
# y  - macierz reprezentująca kanał y.

# Funkcja zwraca:
# RMS     - (float),
# RMS_AP  - (float),
# RMS_ML  - (float).

RMS, RMS_AP, RMS_ML = wii_RMS_AP_ML(x, y)
</source>

*95% powierzchnia ufności elipsy

<source lang="Python">
# Parametry wejściowe:
# x  - macierz reprezentująca kanał x,
# y  - macierz reprezentująca kanał y.

# Funkcja zwraca:
# e  - 95% powierzchnia ufności elipsy (float).

e = wii_confidence_ellipse_area(x, y)
</source>

*Średnia prędkość przemieszczenia

<source lang="Python">
# Parametry wejściowe:
# wbb_mgr  - obiekt klasy WBBReadManager
# x        - macierz reprezentująca kanał x,
# y        - macierz reprezentująca kanał y,
# plot     - True/False (opcjonalnie).

# Funkcja zwraca:
# mean_velocity - średnia prędkość przemieszczenia,
# velocity_AP   - średnia prędkość przemieszczenia w AP,
# velocity_ML   - średnia prędkość przemieszczenia w ML.

mean_velocity, velocity_AP, velocity_ML = wii_mean_velocity(wbb_mgr, x, y)
</source>

*Procentowa wartość przebywania w czterech ćwiartkach układu współrzędnych

<source lang="Python">
# Parametry wejściowe:
# wbb_mgr  - obiekt klasy  WBBReadManager,
# x        - macierz reprezentująca kanał x,
# y        - macierz reprezentująca kanał y,
# plot     - True/False (opcjonalnie). 

# Funkcja zwraca:
# top_right     - procentowa wartość przebywania w prawej górnej ćwiartce układu współrzędnych (float),
# top_left      - procentowa wartość przebywania w lewej górnej ćwiartce układu współrzędnych (float),
# bottom_right  - procentowa wartość przebywania w prawej dolnej ćwiartce układu współrzędnych (float),
# bottom_left   - procentowa wartość przebywania w lewej dolnej ćwiartce układu współrzędnych (float).

top_right, top_left, bottom_right, bottom_left = wii_get_percentages_values(wbb_mgr, x, y, plot=False)
</source> -->