Code Samples¶
Make sure that you’ve installed BrainFlow package before running the code samples below.
See Installation Instructions for details.
Python¶
To run some signal processing samples, you may need to install:
matplotlib
pandas
mne
pyqtgraph
BrainFlow doesn’t use these packages and doesn’t install them, but the packages will be used in demos below.
Python Get Data from a Board¶
import argparse
import time
from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds, BrainFlowPresets
def main():
BoardShim.enable_dev_board_logger()
parser = argparse.ArgumentParser()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument('--timeout', type=int, help='timeout for device discovery or connection', required=False,
default=0)
parser.add_argument('--ip-port', type=int, help='ip port', required=False, default=0)
parser.add_argument('--ip-protocol', type=int, help='ip protocol, check IpProtocolType enum', required=False,
default=0)
parser.add_argument('--ip-address', type=str, help='ip address', required=False, default='')
parser.add_argument('--serial-port', type=str, help='serial port', required=False, default='')
parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='')
parser.add_argument('--other-info', type=str, help='other info', required=False, default='')
parser.add_argument('--serial-number', type=str, help='serial number', required=False, default='')
parser.add_argument('--board-id', type=int, help='board id, check docs to get a list of supported boards',
required=True)
parser.add_argument('--file', type=str, help='file', required=False, default='')
parser.add_argument('--master-board', type=int, help='master board id for streaming and playback boards',
required=False, default=BoardIds.NO_BOARD)
args = parser.parse_args()
params = BrainFlowInputParams()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.serial_number = args.serial_number
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
params.file = args.file
params.master_board = args.master_board
board = BoardShim(args.board_id, params)
board.prepare_session()
board.start_stream ()
time.sleep(10)
# data = board.get_current_board_data (256) # get latest 256 packages or less, doesnt remove them from internal buffer
data = board.get_board_data() # get all data and remove it from internal buffer
board.stop_stream()
board.release_session()
print(data)
if __name__ == "__main__":
main()
Python Markers¶
import argparse
import time
from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds, BrainFlowPresets
def main():
BoardShim.enable_dev_board_logger()
parser = argparse.ArgumentParser()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument('--timeout', type=int, help='timeout for device discovery or connection', required=False,
default=0)
parser.add_argument('--ip-port', type=int, help='ip port', required=False, default=0)
parser.add_argument('--ip-protocol', type=int, help='ip protocol, check IpProtocolType enum', required=False,
default=0)
parser.add_argument('--ip-address', type=str, help='ip address', required=False, default='')
parser.add_argument('--serial-port', type=str, help='serial port', required=False, default='')
parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='')
parser.add_argument('--other-info', type=str, help='other info', required=False, default='')
parser.add_argument('--serial-number', type=str, help='serial number', required=False, default='')
parser.add_argument('--board-id', type=int, help='board id, check docs to get a list of supported boards',
required=True)
parser.add_argument('--file', type=str, help='file', required=False, default='')
parser.add_argument('--master-board', type=int, help='master board id for streaming and playback boards',
required=False, default=BoardIds.NO_BOARD)
parser.add_argument('--preset', type=int, help='preset for streaming and playback boards',
required=False, default=BrainFlowPresets.DEFAULT_PRESET)
args = parser.parse_args()
params = BrainFlowInputParams()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.serial_number = args.serial_number
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
params.file = args.file
params.master_board = args.master_board
params.preset = args.preset
board = BoardShim(args.board_id, params)
board.prepare_session()
board.start_stream()
for i in range(10):
time.sleep(1)
board.insert_marker(i + 1)
data = board.get_board_data()
board.stop_stream()
board.release_session()
print(data)
if __name__ == "__main__":
main()
Python Read Write File¶
import time
import numpy as np
import pandas as pd
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread')
time.sleep(10)
data = board.get_board_data()
board.stop_stream()
board.release_session()
# demo how to convert it to pandas DF and plot data
eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value)
df = pd.DataFrame(np.transpose(data))
print('Data From the Board')
print(df.head(10))
# demo for data serialization using brainflow API, we recommend to use it instead pandas.to_csv()
DataFilter.write_file(data, 'test.csv', 'w') # use 'a' for append mode
restored_data = DataFilter.read_file('test.csv')
restored_df = pd.DataFrame(np.transpose(restored_data))
print('Data From the File')
print(restored_df.head(10))
if __name__ == "__main__":
main()
Python Downsample Data¶
import time
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, AggOperations
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread')
time.sleep(10)
data = board.get_board_data(20)
board.stop_stream()
board.release_session()
eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value)
# demo for downsampling, it just aggregates data
for count, channel in enumerate(eeg_channels):
print('Original data for channel %d:' % channel)
print(data[channel])
if count == 0:
downsampled_data = DataFilter.perform_downsampling(data[channel], 3, AggOperations.MEDIAN.value)
elif count == 1:
downsampled_data = DataFilter.perform_downsampling(data[channel], 2, AggOperations.MEAN.value)
else:
downsampled_data = DataFilter.perform_downsampling(data[channel], 2, AggOperations.EACH.value)
print('Downsampled data for channel %d:' % channel)
print(downsampled_data)
if __name__ == "__main__":
main()
Python Transforms¶
import time
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, WindowOperations, WaveletTypes
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board_id = BoardIds.SYNTHETIC_BOARD.value
sampling_rate = BoardShim.get_sampling_rate(board_id)
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread')
time.sleep(10)
data = board.get_current_board_data(256)
board.stop_stream()
board.release_session()
eeg_channels = BoardShim.get_eeg_channels(board_id)
# demo for transforms
for count, channel in enumerate(eeg_channels):
print('Original data for channel %d:' % channel)
print(data[channel])
# demo for wavelet transforms
# wavelet_coeffs format is[A(J) D(J) D(J-1) ..... D(1)] where J is decomposition level, A - app coeffs, D - detailed coeffs
# lengths array stores lengths for each block
wavelet_coeffs, lengths = DataFilter.perform_wavelet_transform(data[channel], WaveletTypes.DB5, 3)
app_coefs = wavelet_coeffs[0: lengths[0]]
detailed_coeffs_first_block = wavelet_coeffs[lengths[0]: lengths[1]]
# you can do smth with wavelet coeffs here, for example denoising works via thresholds
# for wavelets coefficients
restored_data = DataFilter.perform_inverse_wavelet_transform((wavelet_coeffs, lengths), data[channel].shape[0],
WaveletTypes.DB5, 3)
print('Restored data after wavelet transform for channel %d:' % channel)
print(restored_data)
# demo for fft, len of data must be a power of 2
fft_data = DataFilter.perform_fft(data[channel], WindowOperations.NO_WINDOW.value)
# len of fft_data is N / 2 + 1
restored_fft_data = DataFilter.perform_ifft(fft_data)
print('Restored data after fft for channel %d:' % channel)
print(restored_fft_data)
if __name__ == "__main__":
main()
Python Signal Filtering¶
import time
import matplotlib
import numpy as np
import pandas as pd
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, AggOperations, NoiseTypes
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board_id = BoardIds.SYNTHETIC_BOARD.value
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread')
time.sleep(10)
data = board.get_board_data()
board.stop_stream()
board.release_session()
# demo how to convert it to pandas DF and plot data
eeg_channels = BoardShim.get_eeg_channels(board_id)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('before_processing.png')
# for demo apply different filters to different channels, in production choose one
for count, channel in enumerate(eeg_channels):
# filters work in-place
if count == 0:
DataFilter.perform_bandpass(data[channel], BoardShim.get_sampling_rate(board_id), 2.0, 50.0, 4,
FilterTypes.BESSEL_ZERO_PHASE, 0)
elif count == 1:
DataFilter.perform_bandstop(data[channel], BoardShim.get_sampling_rate(board_id), 48.0, 52.0, 3,
FilterTypes.BUTTERWORTH_ZERO_PHASE, 0)
elif count == 2:
DataFilter.perform_lowpass(data[channel], BoardShim.get_sampling_rate(board_id), 50.0, 5,
FilterTypes.CHEBYSHEV_TYPE_1_ZERO_PHASE, 1)
elif count == 3:
DataFilter.perform_highpass(data[channel], BoardShim.get_sampling_rate(board_id), 2.0, 4,
FilterTypes.BUTTERWORTH, 0)
elif count == 4:
DataFilter.perform_rolling_filter(data[channel], 3, AggOperations.MEAN.value)
else:
DataFilter.remove_environmental_noise(data[channel], BoardShim.get_sampling_rate(board_id),
NoiseTypes.FIFTY.value)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('after_processing.png')
if __name__ == "__main__":
main()
Python Denoising¶
import time
import matplotlib
import numpy as np
import pandas as pd
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, AggOperations, WaveletTypes, NoiseEstimationLevelTypes, \
WaveletExtensionTypes, ThresholdTypes, WaveletDenoisingTypes
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board_id = BoardIds.SYNTHETIC_BOARD.value
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread')
time.sleep(10)
data = board.get_current_board_data(500)
board.stop_stream()
board.release_session()
# demo how to convert it to pandas DF and plot data
eeg_channels = BoardShim.get_eeg_channels(board_id)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('before_processing.png')
# demo for denoising, apply different methods to different channels for demo
for count, channel in enumerate(eeg_channels):
# first of all you can try simple moving median or moving average with different window size
if count == 0:
DataFilter.perform_rolling_filter(data[channel], 3, AggOperations.MEAN.value)
elif count == 1:
DataFilter.perform_rolling_filter(data[channel], 3, AggOperations.MEDIAN.value)
# if methods above dont work for your signal you can try wavelet based denoising
# feel free to try different parameters
else:
DataFilter.perform_wavelet_denoising(data[channel], WaveletTypes.BIOR3_9, 3,
WaveletDenoisingTypes.SURESHRINK, ThresholdTypes.HARD,
WaveletExtensionTypes.SYMMETRIC, NoiseEstimationLevelTypes.FIRST_LEVEL)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('after_processing.png')
if __name__ == "__main__":
main()
Python MNE Integration¶
import time
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds
import mne
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board = BoardShim(BoardIds.SYNTHETIC_BOARD.value, params)
board.prepare_session()
board.start_stream()
time.sleep(10)
data = board.get_board_data()
board.stop_stream()
board.release_session()
eeg_channels = BoardShim.get_eeg_channels(BoardIds.SYNTHETIC_BOARD.value)
eeg_data = data[eeg_channels, :]
eeg_data = eeg_data / 1000000 # BrainFlow returns uV, convert to V for MNE
# Creating MNE objects from brainflow data arrays
ch_types = ['eeg'] * len(eeg_channels)
ch_names = BoardShim.get_eeg_names(BoardIds.SYNTHETIC_BOARD.value)
sfreq = BoardShim.get_sampling_rate(BoardIds.SYNTHETIC_BOARD.value)
info = mne.create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
raw = mne.io.RawArray(eeg_data, info)
# its time to plot something!
raw.plot_psd(average=True)
plt.savefig('psd.png')
if __name__ == '__main__':
main()
Python Band Power¶
import time
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, WindowOperations, DetrendOperations
def main():
BoardShim.enable_dev_board_logger()
# use synthetic board for demo
params = BrainFlowInputParams()
board_id = BoardIds.SYNTHETIC_BOARD.value
board_descr = BoardShim.get_board_descr(board_id)
sampling_rate = int(board_descr['sampling_rate'])
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread')
time.sleep(10)
nfft = DataFilter.get_nearest_power_of_two(sampling_rate)
data = board.get_board_data()
board.stop_stream()
board.release_session()
eeg_channels = board_descr['eeg_channels']
# second eeg channel of synthetic board is a sine wave at 10Hz, should see huge alpha
eeg_channel = eeg_channels[1]
# optional detrend
DataFilter.detrend(data[eeg_channel], DetrendOperations.LINEAR.value)
psd = DataFilter.get_psd_welch(data[eeg_channel], nfft, nfft // 2, sampling_rate,
WindowOperations.BLACKMAN_HARRIS.value)
band_power_alpha = DataFilter.get_band_power(psd, 7.0, 13.0)
band_power_beta = DataFilter.get_band_power(psd, 14.0, 30.0)
print("alpha/beta:%f", band_power_alpha / band_power_beta)
if __name__ == "__main__":
main()
Python EEG Metrics¶
import argparse
import time
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels
from brainflow.data_filter import DataFilter
from brainflow.ml_model import MLModel, BrainFlowMetrics, BrainFlowClassifiers, BrainFlowModelParams
def main():
BoardShim.enable_board_logger()
DataFilter.enable_data_logger()
MLModel.enable_ml_logger()
parser = argparse.ArgumentParser()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument('--timeout', type=int, help='timeout for device discovery or connection', required=False,
default=0)
parser.add_argument('--ip-port', type=int, help='ip port', required=False, default=0)
parser.add_argument('--ip-protocol', type=int, help='ip protocol, check IpProtocolType enum', required=False,
default=0)
parser.add_argument('--ip-address', type=str, help='ip address', required=False, default='')
parser.add_argument('--serial-port', type=str, help='serial port', required=False, default='')
parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='')
parser.add_argument('--other-info', type=str, help='other info', required=False, default='')
parser.add_argument('--streamer-params', type=str, help='streamer params', required=False, default='')
parser.add_argument('--serial-number', type=str, help='serial number', required=False, default='')
parser.add_argument('--board-id', type=int, help='board id, check docs to get a list of supported boards',
required=True)
parser.add_argument('--file', type=str, help='file', required=False, default='')
args = parser.parse_args()
params = BrainFlowInputParams()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.serial_number = args.serial_number
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
params.file = args.file
board = BoardShim(args.board_id, params)
master_board_id = board.get_board_id()
sampling_rate = BoardShim.get_sampling_rate(master_board_id)
board.prepare_session()
board.start_stream(45000, args.streamer_params)
BoardShim.log_message(LogLevels.LEVEL_INFO.value, 'start sleeping in the main thread')
time.sleep(5) # recommended window size for eeg metric calculation is at least 4 seconds, bigger is better
data = board.get_board_data()
board.stop_stream()
board.release_session()
eeg_channels = BoardShim.get_eeg_channels(int(master_board_id))
bands = DataFilter.get_avg_band_powers(data, eeg_channels, sampling_rate, True)
feature_vector = bands[0]
print(feature_vector)
mindfulness_params = BrainFlowModelParams(BrainFlowMetrics.MINDFULNESS.value,
BrainFlowClassifiers.DEFAULT_CLASSIFIER.value)
mindfulness = MLModel(mindfulness_params)
mindfulness.prepare()
print('Mindfulness: %s' % str(mindfulness.predict(feature_vector)))
mindfulness.release()
restfulness_params = BrainFlowModelParams(BrainFlowMetrics.RESTFULNESS.value,
BrainFlowClassifiers.DEFAULT_CLASSIFIER.value)
restfulness = MLModel(restfulness_params)
restfulness.prepare()
print('Restfulness: %s' % str(restfulness.predict(feature_vector)))
restfulness.release()
if __name__ == "__main__":
main()
Python ICA¶
import time
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from brainflow.board_shim import BoardShim, BoardIds, BrainFlowInputParams
from brainflow.data_filter import DataFilter
def main():
board_id = BoardIds.SYNTHETIC_BOARD
eeg_channels = BoardShim.get_eeg_channels(board_id)
params = BrainFlowInputParams()
board = BoardShim(board_id, params)
board.prepare_session()
board.start_stream()
time.sleep(10)
data = board.get_board_data(500)
board.stop_stream()
board.release_session()
channel_to_use = eeg_channels[4]
data = data[channel_to_use, :]
# provide 5 chunks of data for components selection
data = data.reshape(5, 100)
data = np.ascontiguousarray(data)
w, k, a, s = DataFilter.perform_ica(data, 2)
fig, axs = plt.subplots(2, 1)
axs[0].plot(s[0, :])
axs[0].set_title('Unmixed signal 1')
axs[1].plot(s[1, :])
axs[1].set_title('Unmixed signal 2')
plt.savefig('unmixed_signal.png')
if __name__ == "__main__":
main()
Python Real Time Plot¶
Extra requirements for this code sample:
PyQt5==5.15.7
PyQt5-Qt5==5.15.2
PyQt5-sip==12.11.0
pyqtgraph==0.12.4
brainflow
import argparse
import logging
import pyqtgraph as pg
from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, DetrendOperations
from pyqtgraph.Qt import QtGui, QtCore
class Graph:
def __init__(self, board_shim):
self.board_id = board_shim.get_board_id()
self.board_shim = board_shim
self.exg_channels = BoardShim.get_exg_channels(self.board_id)
self.sampling_rate = BoardShim.get_sampling_rate(self.board_id)
self.update_speed_ms = 50
self.window_size = 4
self.num_points = self.window_size * self.sampling_rate
self.app = QtGui.QApplication([])
self.win = pg.GraphicsWindow(title='BrainFlow Plot', size=(800, 600))
self._init_timeseries()
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(self.update_speed_ms)
QtGui.QApplication.instance().exec_()
def _init_timeseries(self):
self.plots = list()
self.curves = list()
for i in range(len(self.exg_channels)):
p = self.win.addPlot(row=i, col=0)
p.showAxis('left', False)
p.setMenuEnabled('left', False)
p.showAxis('bottom', False)
p.setMenuEnabled('bottom', False)
if i == 0:
p.setTitle('TimeSeries Plot')
self.plots.append(p)
curve = p.plot()
self.curves.append(curve)
def update(self):
data = self.board_shim.get_current_board_data(self.num_points)
for count, channel in enumerate(self.exg_channels):
# plot timeseries
DataFilter.detrend(data[channel], DetrendOperations.CONSTANT.value)
DataFilter.perform_bandpass(data[channel], self.sampling_rate, 3.0, 45.0, 2,
FilterTypes.BUTTERWORTH_ZERO_PHASE, 0)
DataFilter.perform_bandstop(data[channel], self.sampling_rate, 48.0, 52.0, 2,
FilterTypes.BUTTERWORTH_ZERO_PHASE, 0)
DataFilter.perform_bandstop(data[channel], self.sampling_rate, 58.0, 62.0, 2,
FilterTypes.BUTTERWORTH_ZERO_PHASE, 0)
self.curves[count].setData(data[channel].tolist())
self.app.processEvents()
def main():
BoardShim.enable_dev_board_logger()
logging.basicConfig(level=logging.DEBUG)
parser = argparse.ArgumentParser()
# use docs to check which parameters are required for specific board, e.g. for Cyton - set serial port
parser.add_argument('--timeout', type=int, help='timeout for device discovery or connection', required=False,
default=0)
parser.add_argument('--ip-port', type=int, help='ip port', required=False, default=0)
parser.add_argument('--ip-protocol', type=int, help='ip protocol, check IpProtocolType enum', required=False,
default=0)
parser.add_argument('--ip-address', type=str, help='ip address', required=False, default='')
parser.add_argument('--serial-port', type=str, help='serial port', required=False, default='')
parser.add_argument('--mac-address', type=str, help='mac address', required=False, default='')
parser.add_argument('--other-info', type=str, help='other info', required=False, default='')
parser.add_argument('--streamer-params', type=str, help='streamer params', required=False, default='')
parser.add_argument('--serial-number', type=str, help='serial number', required=False, default='')
parser.add_argument('--board-id', type=int, help='board id, check docs to get a list of supported boards',
required=False, default=BoardIds.SYNTHETIC_BOARD)
parser.add_argument('--file', type=str, help='file', required=False, default='')
parser.add_argument('--master-board', type=int, help='master board id for streaming and playback boards',
required=False, default=BoardIds.NO_BOARD)
args = parser.parse_args()
params = BrainFlowInputParams()
params.ip_port = args.ip_port
params.serial_port = args.serial_port
params.mac_address = args.mac_address
params.other_info = args.other_info
params.serial_number = args.serial_number
params.ip_address = args.ip_address
params.ip_protocol = args.ip_protocol
params.timeout = args.timeout
params.file = args.file
params.master_board = args.master_board
board_shim = BoardShim(args.board_id, params)
try:
board_shim.prepare_session()
board_shim.start_stream(450000, args.streamer_params)
Graph(board_shim)
except BaseException:
logging.warning('Exception', exc_info=True)
finally:
logging.info('End')
if board_shim.is_prepared():
logging.info('Releasing session')
board_shim.release_session()
if __name__ == '__main__':
main()
Java¶
Java Get Data from a Board¶
package brainflow.examples;
import java.util.Arrays;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.LogLevels;
public class BrainFlowGetData
{
public static void main (String[] args) throws Exception
{
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = parse_args (args, params);
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
// board_shim.start_stream (); // use this for default options
board_shim.start_stream (450000, "file://file_stream.csv:w");
BoardShim.log_message (LogLevels.LEVEL_INFO.get_code (), "Start sleeping in the main thread");
Thread.sleep (5000);
board_shim.stop_stream ();
System.out.println (board_shim.get_board_data_count ());
double[][] data = board_shim.get_current_board_data (30); // doesnt flush it from ring buffer
// double[][] data = board_shim.get_board_data (); // get all data and flush
// from ring buffer
for (int i = 0; i < data.length; i++)
{
System.out.println (Arrays.toString (data[i]));
}
board_shim.release_session ();
}
private static int parse_args (String[] args, BrainFlowInputParams params)
{
int board_id = -1;
for (int i = 0; i < args.length; i++)
{
if (args[i].equals ("--ip-address"))
{
params.ip_address = args[i + 1];
}
if (args[i].equals ("--ip-address-aux"))
{
params.ip_address_aux = args[i + 1];
}
if (args[i].equals ("--ip-address-anc"))
{
params.ip_address_anc = args[i + 1];
}
if (args[i].equals ("--serial-port"))
{
params.serial_port = args[i + 1];
}
if (args[i].equals ("--ip-port"))
{
params.ip_port = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--ip-port-aux"))
{
params.ip_port_aux = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--ip-port-anc"))
{
params.ip_port_anc = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--ip-protocol"))
{
params.ip_protocol = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--other-info"))
{
params.other_info = args[i + 1];
}
if (args[i].equals ("--board-id"))
{
board_id = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--timeout"))
{
params.timeout = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--serial-number"))
{
params.serial_number = args[i + 1];
}
if (args[i].equals ("--file"))
{
params.file = args[i + 1];
}
if (args[i].equals ("--file-aux"))
{
params.file_aux = args[i + 1];
}
if (args[i].equals ("--file-anc"))
{
params.file_anc = args[i + 1];
}
if (args[i].equals ("--master-board"))
{
params.master_board = Integer.parseInt (args[i + 1]);
}
}
return board_id;
}
}
Java Markers¶
package brainflow.examples;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
public class Markers
{
public static void main (String[] args) throws Exception
{
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = parse_args (args, params);
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (450000, "file://file_stream.csv:w");
for (int i = 1; i < 5; i++)
{
Thread.sleep (1000);
board_shim.insert_marker (i);
}
board_shim.stop_stream ();
board_shim.release_session ();
}
private static int parse_args (String[] args, BrainFlowInputParams params)
{
int board_id = -1;
for (int i = 0; i < args.length; i++)
{
if (args[i].equals ("--ip-address"))
{
params.ip_address = args[i + 1];
}
if (args[i].equals ("--serial-port"))
{
params.serial_port = args[i + 1];
}
if (args[i].equals ("--ip-port"))
{
params.ip_port = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--ip-protocol"))
{
params.ip_protocol = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--other-info"))
{
params.other_info = args[i + 1];
}
if (args[i].equals ("--board-id"))
{
board_id = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--timeout"))
{
params.timeout = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--serial-number"))
{
params.serial_number = args[i + 1];
}
if (args[i].equals ("--file"))
{
params.file = args[i + 1];
}
}
return board_id;
}
}
Java Read Write File¶
package brainflow.examples;
import java.util.Arrays;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
import brainflow.LogLevels;
public class Serialization
{
public static void main (String[] args) throws Exception
{
// use Synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
BoardIds board_id = BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
BoardShim.log_message (LogLevels.LEVEL_INFO, "Start sleeping in the main thread");
Thread.sleep (5000);
board_shim.stop_stream ();
System.out.println (board_shim.get_board_data_count ());
int num_rows = BoardShim.get_num_rows (board_id);
double[][] data = board_shim.get_current_board_data (30);
for (int i = 0; i < num_rows; i++)
{
System.out.println (Arrays.toString (data[i]));
}
board_shim.release_session ();
// demo for serialization
DataFilter.write_file (data, "test.csv", "w");
double[][] restored_data = DataFilter.read_file ("test.csv");
System.out.println ("After Serialization:");
for (int i = 0; i < num_rows; i++)
{
System.out.println (Arrays.toString (restored_data[i]));
}
}
}
Java Downsample Data¶
package brainflow.examples;
import java.util.Arrays;
import brainflow.AggOperations;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
import brainflow.LogLevels;
public class Downsampling
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
BoardIds board_id = BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
BoardShim.log_message (LogLevels.LEVEL_INFO, "Start sleeping in the main thread");
Thread.sleep (5000);
board_shim.stop_stream ();
System.out.println (board_shim.get_board_data_count ());
double[][] data = board_shim.get_board_data (30);
board_shim.release_session ();
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
for (int i = 0; i < eeg_channels.length; i++)
{
System.out.println ("Original data:");
System.out.println (Arrays.toString (data[i]));
// keep each second element, you can use MEAN and MEDIAN as well
double[] downsampled_data = DataFilter.perform_downsampling (data[eeg_channels[i]], 2, AggOperations.EACH);
System.out.println ("Downsampled data:");
System.out.println (Arrays.toString (downsampled_data));
}
}
}
Java Transforms¶
package brainflow.examples;
import java.util.Arrays;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.math3.complex.Complex;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
import brainflow.LogLevels;
import brainflow.WaveletExtensionTypes;
import brainflow.WaveletTypes;
import brainflow.WindowOperations;
public class Transforms
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
BoardIds board_id = BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
BoardShim.log_message (LogLevels.LEVEL_INFO, "Start sleeping in the main thread");
Thread.sleep (10000);
board_shim.stop_stream ();
System.out.println (board_shim.get_board_data_count ());
int num_rows = BoardShim.get_num_rows (board_id);
double[][] data = board_shim.get_current_board_data (64);
for (int i = 0; i < num_rows; i++)
{
System.out.println (Arrays.toString (data[i]));
}
board_shim.release_session ();
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
for (int i = 0; i < eeg_channels.length; i++)
{
System.out.println ("Original data:");
System.out.println (Arrays.toString (data[eeg_channels[i]]));
// demo for wavelet transform
// Pair of coeffs array in format[A(J) D(J) D(J-1) ..... D(1)] where J is a
// decomposition level, A - app coeffs, D - detailed coeffs, and array which
// stores
// length for each block, len of this array is decomposition_length + 1
Pair<double[], int[]> wavelet_data = DataFilter.perform_wavelet_transform (data[eeg_channels[i]],
WaveletTypes.DB4, 3, WaveletExtensionTypes.SYMMETRIC);
// print approximation coeffs
for (int j = 0; j < wavelet_data.getRight ()[0]; j++)
{
System.out.print (wavelet_data.getLeft ()[j] + " ");
}
System.out.println ();
// you can do smth with these coeffs here, for example denoising works via
// thresholds for wavelet coeffs
double[] restored_data = DataFilter.perform_inverse_wavelet_transform (wavelet_data,
data[eeg_channels[i]].length, WaveletTypes.DB4, 3, WaveletExtensionTypes.SYMMETRIC);
System.out.println ("Restored data after wavelet:");
System.out.println (Arrays.toString (restored_data));
// demo for fft works only for power of 2
// len of fft_data is N / 2 + 1
Complex[] fft_data = DataFilter.perform_fft (data[eeg_channels[i]], 0, 64, WindowOperations.NO_WINDOW);
double[] restored_fft_data = DataFilter.perform_ifft (fft_data);
System.out.println ("Restored data after fft:");
System.out.println (Arrays.toString (restored_fft_data));
}
}
}
Java Signal Filtering¶
package brainflow.examples;
import java.util.Arrays;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
import brainflow.FilterTypes;
import brainflow.LogLevels;
import brainflow.NoiseTypes;
public class SignalFiltering
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
BoardIds board_id = BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
BoardShim.log_message (LogLevels.LEVEL_INFO, "Start sleeping in the main thread");
Thread.sleep (5000);
board_shim.stop_stream ();
System.out.println (board_shim.get_board_data_count ());
int num_rows = BoardShim.get_num_rows (board_id);
double[][] data = board_shim.get_current_board_data (30);
for (int i = 0; i < num_rows; i++)
{
System.out.println (Arrays.toString (data[i]));
}
board_shim.release_session ();
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
for (int i = 0; i < eeg_channels.length; i++)
{
// just for demo - apply different filters to different eeg channels
switch (i)
{
case 0:
DataFilter.perform_lowpass (data[eeg_channels[i]], BoardShim.get_sampling_rate (board_id), 50.0, 4,
FilterTypes.BESSEL, 0.0);
break;
case 1:
DataFilter.perform_highpass (data[eeg_channels[i]], BoardShim.get_sampling_rate (board_id), 3.0, 4,
FilterTypes.BUTTERWORTH, 0.0);
break;
case 2:
DataFilter.perform_bandpass (data[eeg_channels[i]], BoardShim.get_sampling_rate (board_id), 3.0,
50.0, 4, FilterTypes.CHEBYSHEV_TYPE_1, 1.0);
break;
case 3:
DataFilter.perform_bandstop (data[eeg_channels[i]], BoardShim.get_sampling_rate (board_id), 48.0,
52.0, 4, FilterTypes.CHEBYSHEV_TYPE_1, 1.0);
break;
default:
DataFilter.remove_environmental_noise (data[eeg_channels[i]],
BoardShim.get_sampling_rate (board_id), NoiseTypes.FIFTY);;
break;
}
}
System.out.println ("After signal processing:");
for (int i = 0; i < num_rows; i++)
{
System.out.println (Arrays.toString (data[i]));
}
}
}
Java Denoising¶
package brainflow.examples;
import java.util.Arrays;
import brainflow.AggOperations;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
import brainflow.LogLevels;
import brainflow.NoiseEstimationLevelTypes;
import brainflow.ThresholdTypes;
import brainflow.WaveletDenoisingTypes;
import brainflow.WaveletExtensionTypes;
import brainflow.WaveletTypes;
public class Denoising
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
BoardIds board_id = BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
BoardShim.log_message (LogLevels.LEVEL_INFO, "Start sleeping in the main thread");
Thread.sleep (7000);
board_shim.stop_stream ();
System.out.println (board_shim.get_board_data_count ());
int num_rows = BoardShim.get_num_rows (board_id);
double[][] data = board_shim.get_current_board_data (512);
for (int i = 0; i < num_rows; i++)
{
System.out.println (Arrays.toString (data[i]));
}
board_shim.release_session ();
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
for (int i = 0; i < eeg_channels.length; i++)
{
// just for demo - apply different methods to different eeg channels
switch (i)
{
// first of all you can try simple moving average or moving median
case 0:
DataFilter.perform_rolling_filter (data[eeg_channels[i]], 3, AggOperations.MEAN);
break;
case 1:
DataFilter.perform_rolling_filter (data[eeg_channels[i]], 3, AggOperations.MEDIAN);
break;
// if methods above dont work good for you you should try wavelet based
// denoising
default:
// try different functions and different decomposition levels here
DataFilter.perform_wavelet_denoising (data[eeg_channels[i]], WaveletTypes.BIOR3_9, 3,
WaveletDenoisingTypes.SURESHRINK, ThresholdTypes.HARD, WaveletExtensionTypes.SYMMETRIC,
NoiseEstimationLevelTypes.FIRST_LEVEL);
break;
}
}
System.out.println ("After signal processing:");
for (int i = 0; i < num_rows; i++)
{
System.out.println (Arrays.toString (data[i]));
}
}
}
Java Band Power¶
package brainflow.examples;
import java.util.List;
import org.apache.commons.lang3.tuple.Pair;
import brainflow.BoardDescr;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
import brainflow.DetrendOperations;
import brainflow.LogLevels;
import brainflow.WindowOperations;
public class BandPower
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
BoardIds board_id = BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, params);
BoardDescr board_descr = BoardShim.get_board_descr (BoardDescr.class, board_id);
int sampling_rate = board_descr.sampling_rate;
int nfft = DataFilter.get_nearest_power_of_two (sampling_rate);
board_shim.prepare_session ();
board_shim.start_stream (3600);
BoardShim.log_message (LogLevels.LEVEL_INFO, "Start sleeping in the main thread");
Thread.sleep (10000);
board_shim.stop_stream ();
double[][] data = board_shim.get_board_data ();
board_shim.release_session ();
List<Integer> eeg_channels = board_descr.eeg_channels;
// seconds channel of synthetic board has big 'alpha' use it for test
int eeg_channel = eeg_channels.get (1).intValue ();
// optional: detrend before psd
DataFilter.detrend (data[eeg_channel], DetrendOperations.LINEAR);
Pair<double[], double[]> psd = DataFilter.get_psd_welch (data[eeg_channel], nfft, nfft / 2, sampling_rate,
WindowOperations.HANNING);
double band_power_alpha = DataFilter.get_band_power (psd, 7.0, 13.0);
double band_power_beta = DataFilter.get_band_power (psd, 14.0, 30.0);
System.out.println ("Alpha/Beta Ratio: " + (band_power_alpha / band_power_beta));
}
}
Java EEG Metrics¶
package brainflow.examples;
import org.apache.commons.lang3.tuple.Pair;
import brainflow.BoardShim;
import brainflow.BrainFlowClassifiers;
import brainflow.BrainFlowInputParams;
import brainflow.BrainFlowMetrics;
import brainflow.BrainFlowModelParams;
import brainflow.DataFilter;
import brainflow.LogLevels;
import brainflow.MLModel;
public class EEGMetrics
{
public static void main (String[] args) throws Exception
{
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = parse_args (args, params);
BoardShim board_shim = new BoardShim (board_id, params);
int master_board_id = board_shim.get_board_id ();
int sampling_rate = BoardShim.get_sampling_rate (master_board_id);
int[] eeg_channels = BoardShim.get_eeg_channels (master_board_id);
board_shim.prepare_session ();
board_shim.start_stream (3600);
BoardShim.log_message (LogLevels.LEVEL_INFO, "Start sleeping in the main thread");
// recommended window size for eeg metric calculation is at least 4 seconds,
// bigger is better
Thread.sleep (5000);
board_shim.stop_stream ();
double[][] data = board_shim.get_board_data ();
board_shim.release_session ();
Pair<double[], double[]> bands = DataFilter.get_avg_band_powers (data, eeg_channels, sampling_rate, true);
double[] feature_vector = bands.getLeft ();
BrainFlowModelParams model_params = new BrainFlowModelParams (BrainFlowMetrics.MINDFULNESS,
BrainFlowClassifiers.DEFAULT_CLASSIFIER);
MLModel model = new MLModel (model_params);
model.prepare ();
System.out.print ("Score: " + model.predict (feature_vector)[0]);
model.release ();
}
private static int parse_args (String[] args, BrainFlowInputParams params)
{
int board_id = -1;
for (int i = 0; i < args.length; i++)
{
if (args[i].equals ("--ip-address"))
{
params.ip_address = args[i + 1];
}
if (args[i].equals ("--serial-port"))
{
params.serial_port = args[i + 1];
}
if (args[i].equals ("--ip-port"))
{
params.ip_port = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--ip-protocol"))
{
params.ip_protocol = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--other-info"))
{
params.other_info = args[i + 1];
}
if (args[i].equals ("--board-id"))
{
board_id = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--timeout"))
{
params.timeout = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--serial-number"))
{
params.serial_number = args[i + 1];
}
if (args[i].equals ("--file"))
{
params.file = args[i + 1];
}
}
return board_id;
}
}
Java ICA¶
package brainflow.examples;
import java.util.List;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
public class ICA
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
BoardIds board_id = BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
Thread.sleep (10000);
board_shim.stop_stream ();
double[][] data = board_shim.get_board_data (500);
board_shim.release_session ();
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
int eeg_channel = eeg_channels[1];
double[][] ica_data = DataFilter.reshape_data_to_2d (5, 100, data[eeg_channel]);
List<double[][]> ica = DataFilter.perform_ica (ica_data, 2);
System.out.println ("Completed");
}
}
C#¶
C# Read Data from a Board¶
using System;
using brainflow;
using brainflow.math;
namespace examples
{
class GetBoardData
{
static void Main (string[] args)
{
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = parse_args (args, input_params);
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream ();
System.Threading.Thread.Sleep (5000);
board_shim.stop_stream ();
double[,] unprocessed_data = board_shim.get_current_board_data (20);
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
foreach (var index in eeg_channels)
Console.WriteLine ("[{0}]", string.Join (", ", unprocessed_data.GetRow (index)));
board_shim.release_session ();
}
static int parse_args (string[] args, BrainFlowInputParams input_params)
{
int board_id = (int)BoardIds.SYNTHETIC_BOARD; //assume synthetic board by default
// use docs to get params for your specific board, e.g. set serial_port for Cyton
for (int i = 0; i < args.Length; i++)
{
if (args[i].Equals ("--ip-address"))
{
input_params.ip_address = args[i + 1];
}
if (args[i].Equals ("--mac-address"))
{
input_params.mac_address = args[i + 1];
}
if (args[i].Equals ("--serial-port"))
{
input_params.serial_port = args[i + 1];
}
if (args[i].Equals ("--other-info"))
{
input_params.other_info = args[i + 1];
}
if (args[i].Equals ("--ip-port"))
{
input_params.ip_port = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--ip-protocol"))
{
input_params.ip_protocol = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--board-id"))
{
board_id = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--timeout"))
{
input_params.timeout = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--serial-number"))
{
input_params.serial_number = args[i + 1];
}
if (args[i].Equals ("--file"))
{
input_params.file = args[i + 1];
}
}
return board_id;
}
}
}
C# Markers¶
using System;
using brainflow;
using brainflow.math;
namespace examples
{
class Markers
{
static void Main (string[] args)
{
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = parse_args (args, input_params);
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream ();
board_shim.add_streamer ("file://data.csv:w");
for (int i = 1; i < 5; i++)
{
System.Threading.Thread.Sleep (1000);
board_shim.insert_marker (i);
}
board_shim.stop_stream ();
board_shim.release_session ();
}
static int parse_args (string[] args, BrainFlowInputParams input_params)
{
int board_id = (int)BoardIds.SYNTHETIC_BOARD; //assume synthetic board by default
// use docs to get params for your specific board, e.g. set serial_port for Cyton
for (int i = 0; i < args.Length; i++)
{
if (args[i].Equals ("--ip-address"))
{
input_params.ip_address = args[i + 1];
}
if (args[i].Equals ("--mac-address"))
{
input_params.mac_address = args[i + 1];
}
if (args[i].Equals ("--serial-port"))
{
input_params.serial_port = args[i + 1];
}
if (args[i].Equals ("--other-info"))
{
input_params.other_info = args[i + 1];
}
if (args[i].Equals ("--ip-port"))
{
input_params.ip_port = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--ip-protocol"))
{
input_params.ip_protocol = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--board-id"))
{
board_id = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--timeout"))
{
input_params.timeout = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--serial-number"))
{
input_params.serial_number = args[i + 1];
}
if (args[i].Equals ("--file"))
{
input_params.file = args[i + 1];
}
}
return board_id;
}
}
}
C# Read Write File¶
using System;
using brainflow;
using brainflow.math;
namespace examples
{
class Serialization
{
static void Main (string[] args)
{
// use synthetic board for demo
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = (int)BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
System.Threading.Thread.Sleep (5000);
board_shim.stop_stream ();
double[,] unprocessed_data = board_shim.get_current_board_data (20);
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
Console.WriteLine ("Before serialization:");
foreach (var index in eeg_channels)
Console.WriteLine ("[{0}]", string.Join (", ", unprocessed_data.GetRow (index)));
board_shim.release_session ();
// demo for data serialization
DataFilter.write_file (unprocessed_data, "test.csv", "w");
double[,] restored_data = DataFilter.read_file ("test.csv");
Console.WriteLine ("After Serialization:");
foreach (var index in eeg_channels)
Console.WriteLine ("[{0}]", string.Join (", ", restored_data.GetRow (index)));
}
}
}
C# Downsample Data¶
using System;
using brainflow;
using brainflow.math;
namespace examples
{
class Downsampling
{
static void Main (string[] args)
{
// use synthetic board for demo
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = (int)BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
System.Threading.Thread.Sleep (5000);
board_shim.stop_stream ();
double[,] unprocessed_data = board_shim.get_board_data ();
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
board_shim.release_session ();
for (int i = 0; i < eeg_channels.Length; i++)
{
Console.WriteLine ("Before processing:");
Console.WriteLine ("[{0}]", string.Join (", ", unprocessed_data.GetRow (eeg_channels[i])));
// you can use MEAN, MEDIAN or EACH for downsampling
double[] filtered = DataFilter.perform_downsampling (unprocessed_data.GetRow (eeg_channels[i]), 3, (int)AggOperations.MEDIAN);
Console.WriteLine ("Before processing:");
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
}
}
}
}
C# Transforms¶
using System;
using System.Numerics;
using brainflow;
using brainflow.math;
namespace examples
{
class Transforms
{
static void Main (string[] args)
{
// use synthetic board for demo
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = (int)BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
System.Threading.Thread.Sleep (5000);
board_shim.stop_stream ();
double[,] unprocessed_data = board_shim.get_current_board_data (64);
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
board_shim.release_session ();
for (int i = 0; i < eeg_channels.Length; i++)
{
Console.WriteLine ("Original data:");
Console.WriteLine ("[{0}]", string.Join (", ", unprocessed_data.GetRow (eeg_channels[i])));
// demo for wavelet transform
// tuple of coeffs array in format[A(J) D(J) D(J-1) ..... D(1)] where J is a
// decomposition level, A - app coeffs, D - detailed coeffs, and array which stores
// length for each block, len of this array is decomposition_length + 1
Tuple<double[], int[]> wavelet_data = DataFilter.perform_wavelet_transform (unprocessed_data.GetRow (eeg_channels[i]), (int)WaveletTypes.DB4, 1, (int)WaveletExtensionTypes.SYMMETRIC);
// print app coeffs
for (int j = 0; j < wavelet_data.Item2[0]; j++)
{
Console.Write (wavelet_data.Item1[j] + " ");
}
Console.WriteLine ();
// you can do smth with wavelet coeffs here, for example denoising works via thresholds for wavelets coeffs
double[] restored_data = DataFilter.perform_inverse_wavelet_transform (wavelet_data, unprocessed_data.GetRow (eeg_channels[i]).Length, (int)WaveletTypes.DB4, 1, (int)WaveletExtensionTypes.SYMMETRIC);
Console.WriteLine ("Restored wavelet data:");
Console.WriteLine ("[{0}]", string.Join (", ", restored_data));
// demo for fft
// end_pos - start_pos must be a power of 2
Complex[] fft_data = DataFilter.perform_fft (unprocessed_data.GetRow (eeg_channels[i]), 0, 64, (int)WindowOperations.HAMMING);
// len of fft_data is N / 2 + 1
double[] restored_fft_data = DataFilter.perform_ifft (fft_data);
Console.WriteLine ("Restored fft data:");
Console.WriteLine ("[{0}]", string.Join (", ", restored_fft_data));
}
}
}
}
C# Signal Filtering¶
using System;
using brainflow;
using brainflow.math;
namespace examples
{
class SignalFiltering
{
static void Main (string[] args)
{
// use synthetic board for demo
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = (int)BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
System.Threading.Thread.Sleep (5000);
board_shim.stop_stream ();
double[,] unprocessed_data = board_shim.get_current_board_data (20);
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
board_shim.release_session ();
for (int i = 0; i < eeg_channels.Length; i++)
{
DataFilter.detrend (unprocessed_data, eeg_channels[i], (int)DetrendOperations.CONSTANT);
DataFilter.perform_bandstop (unprocessed_data, eeg_channels[i], BoardShim.get_sampling_rate (board_id), 48.0, 52.0, 4, (int)FilterTypes.BUTTERWORTH, 0.0);
DataFilter.perform_bandpass (unprocessed_data, eeg_channels[i], BoardShim.get_sampling_rate (board_id), 4.0, 30.0, 4, (int)FilterTypes.BUTTERWORTH, 0.0);
}
}
}
}
C# Denoising¶
using System;
using brainflow;
using brainflow.math;
namespace examples
{
class Denoising
{
static void Main (string[] args)
{
// use synthetic board for demo
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = (int)BoardIds.SYNTHETIC_BOARD;
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
System.Threading.Thread.Sleep (5000);
board_shim.stop_stream ();
double[,] unprocessed_data = board_shim.get_current_board_data (64);
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
foreach (var index in eeg_channels)
Console.WriteLine ("[{0}]", string.Join (", ", unprocessed_data.GetRow (index)));
board_shim.release_session ();
// for demo apply different methods to different channels
double[] filtered;
for (int i = 0; i < eeg_channels.Length; i++)
{
switch (i)
{
// first of all you can try simple moving average or moving median
case 0:
filtered = DataFilter.perform_rolling_filter (unprocessed_data.GetRow (eeg_channels[i]), 3, (int)AggOperations.MEAN);
Console.WriteLine ("Filtered channel " + eeg_channels[i]);
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
break;
case 1:
filtered = DataFilter.perform_rolling_filter (unprocessed_data.GetRow (eeg_channels[i]), 3, (int)AggOperations.MEDIAN);
Console.WriteLine ("Filtered channel " + eeg_channels[i]);
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
break;
// if for your signal these methods dont work good you can try wavelet based denoising
default:
// feel free to try different functions and different decomposition levels
filtered = DataFilter.perform_wavelet_denoising (unprocessed_data.GetRow (eeg_channels[i]), (int)WaveletTypes.BIOR3_9, 3);
Console.WriteLine ("Filtered channel " + eeg_channels[i]);
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
break;
}
}
}
}
}
C# Band Power¶
using System;
using System.Runtime.Serialization;
using brainflow;
using brainflow.math;
namespace examples
{
class BandPower
{
static void Main (string[] args)
{
// use synthetic board for demo
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = (int)BoardIds.SYNTHETIC_BOARD;
BoardDescr board_descr = BoardShim.get_board_descr<BoardDescr> (board_id);
int sampling_rate = board_descr.sampling_rate;
int nfft = DataFilter.get_nearest_power_of_two (sampling_rate);
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
System.Threading.Thread.Sleep (10000);
board_shim.stop_stream ();
double[,] data = board_shim.get_board_data ();
int[] eeg_channels = board_descr.eeg_channels;
// use second channel of synthetic board to see 'alpha'
int channel = eeg_channels[1];
board_shim.release_session ();
double[] detrend = DataFilter.detrend (data.GetRow (channel), (int)DetrendOperations.LINEAR);
Tuple<double[], double[]> psd = DataFilter.get_psd_welch (detrend, nfft, nfft / 2, sampling_rate, (int)WindowOperations.HANNING);
double band_power_alpha = DataFilter.get_band_power (psd, 7.0, 13.0);
double band_power_beta = DataFilter.get_band_power (psd, 14.0, 30.0);
Console.WriteLine ("Alpha/Beta Ratio:" + (band_power_alpha / band_power_beta));
}
}
}
C# EEG Metrics¶
using System;
using brainflow;
using brainflow.math;
namespace examples
{
class EEGMetrics
{
static void Main (string[] args)
{
// use synthetic board for demo
BoardShim.enable_dev_board_logger ();
BrainFlowInputParams input_params = new BrainFlowInputParams ();
int board_id = parse_args (args, input_params);
BoardShim board_shim = new BoardShim (board_id, input_params);
int sampling_rate = BoardShim.get_sampling_rate (board_shim.get_board_id ());
int[] eeg_channels = BoardShim.get_eeg_channels (board_shim.get_board_id ());
board_shim.prepare_session ();
board_shim.start_stream (3600);
System.Threading.Thread.Sleep (10000);
board_shim.stop_stream ();
double[,] data = board_shim.get_board_data ();
board_shim.release_session ();
Tuple<double[], double[]> bands = DataFilter.get_avg_band_powers (data, eeg_channels, sampling_rate, true);
double[] feature_vector = bands.Item1;
BrainFlowModelParams model_params = new BrainFlowModelParams ((int)BrainFlowMetrics.MINDFULNESS, (int)BrainFlowClassifiers.DEFAULT_CLASSIFIER);
MLModel model = new MLModel (model_params);
model.prepare ();
Console.WriteLine ("Score: " + model.predict (feature_vector)[0]);
model.release ();
}
static int parse_args (string[] args, BrainFlowInputParams input_params)
{
int board_id = (int)BoardIds.SYNTHETIC_BOARD; //assume synthetic board by default
// use docs to get params for your specific board, e.g. set serial_port for Cyton
for (int i = 0; i < args.Length; i++)
{
if (args[i].Equals ("--ip-address"))
{
input_params.ip_address = args[i + 1];
}
if (args[i].Equals ("--mac-address"))
{
input_params.mac_address = args[i + 1];
}
if (args[i].Equals ("--serial-port"))
{
input_params.serial_port = args[i + 1];
}
if (args[i].Equals ("--other-info"))
{
input_params.other_info = args[i + 1];
}
if (args[i].Equals ("--ip-port"))
{
input_params.ip_port = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--ip-protocol"))
{
input_params.ip_protocol = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--board-id"))
{
board_id = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--timeout"))
{
input_params.timeout = Convert.ToInt32 (args[i + 1]);
}
if (args[i].Equals ("--serial-number"))
{
input_params.serial_number = args[i + 1];
}
if (args[i].Equals ("--file"))
{
input_params.file = args[i + 1];
}
}
return board_id;
}
}
}
C# ICA¶
using System;
using System.Runtime.Serialization;
using brainflow;
using brainflow.math;
namespace examples
{
class ICA
{
static void Main (string[] args)
{
BoardShim.enable_dev_board_logger ();
int board_id = (int)BoardIds.SYNTHETIC_BOARD;
BoardDescr board_descr = BoardShim.get_board_descr<BoardDescr> (board_id);
int[] eeg_channels = board_descr.eeg_channels;
int channel = eeg_channels[1];
BrainFlowInputParams input_params = new BrainFlowInputParams ();
BoardShim board_shim = new BoardShim (board_id, input_params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
System.Threading.Thread.Sleep (10000);
board_shim.stop_stream ();
double[,] data = board_shim.get_board_data (500);
board_shim.release_session ();
double[,] ica_data = data.GetRow (channel).Reshape(5, 100);
Tuple<double[,], double[,], double[,], double[,]> ica = DataFilter.perform_ica (ica_data, 2);
}
}
}
C++¶
To compile examples below for Linux or MacOS run:
cd cpp_package/examples/get_data
mkdir build
cd build
cmake -DCMAKE_PREFIX_PATH=TYPE_FULL_PATH_TO_BRAINFLOW_INSTALLED_FOLDER ..
# e.g. cmake -DCMAKE_PREFIX_PATH=/home/andrey/brainflow/installed ..
make
For Windows it’s almost the same.
Make sure that compiled dynamic libraries exist in search path before running an executable by doing one of the following:
for Linux and MacOS add them to LD_LIBRARY_PATH env variable
for Windows add them to PATH env variable
or just copypaste them to the folder where your executable is located
CMake File Example¶
cmake_minimum_required (VERSION 3.10)
project (BRAINFLOW_GET_DATA)
set (CMAKE_CXX_STANDARD 11)
set (CMAKE_VERBOSE_MAKEFILE ON)
macro (configure_msvc_runtime)
if (MSVC)
# Default to statically-linked runtime.
if ("${MSVC_RUNTIME}" STREQUAL "")
set (MSVC_RUNTIME "static")
endif ()
# Set compiler options.
set (variables
CMAKE_C_FLAGS_DEBUG
CMAKE_C_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_RELWITHDEBINFO
)
if (${MSVC_RUNTIME} STREQUAL "static")
message(STATUS
"MSVC -> forcing use of statically-linked runtime."
)
foreach (variable ${variables})
if (${variable} MATCHES "/MD")
string (REGEX REPLACE "/MD" "/MT" ${variable} "${${variable}}")
endif ()
endforeach ()
else ()
message (STATUS
"MSVC -> forcing use of dynamically-linked runtime."
)
foreach (variable ${variables})
if (${variable} MATCHES "/MT")
string (REGEX REPLACE "/MT" "/MD" ${variable} "${${variable}}")
endif ()
endforeach ()
endif ()
endif ()
endmacro ()
# link msvc runtime statically
configure_msvc_runtime()
find_package (
brainflow CONFIG REQUIRED
)
add_executable (
brainflow_get_data
src/brainflow_get_data.cpp
)
target_include_directories (
brainflow_get_data PUBLIC
${brainflow_INCLUDE_DIRS}
)
target_link_libraries (
brainflow_get_data PUBLIC
# for some systems(ubuntu for example) order matters
${BrainflowPath}
${MLModulePath}
${DataHandlerPath}
${BoardControllerPath}
)
add_executable (
markers
src/markers.cpp
)
target_include_directories (
markers PUBLIC
${brainflow_INCLUDE_DIRS}
)
target_link_libraries (
markers PUBLIC
# for some systems(ubuntu for example) order matters
${BrainflowPath}
${MLModulePath}
${DataHandlerPath}
${BoardControllerPath}
)
add_executable (
get_data_twice
src/get_data_twice.cpp
)
target_include_directories (
get_data_twice PUBLIC
${brainflow_INCLUDE_DIRS}
)
target_link_libraries (
get_data_twice PUBLIC
# for some systems(ubuntu for example) order matters
${BrainflowPath}
${MLModulePath}
${DataHandlerPath}
${BoardControllerPath}
)
add_executable (
get_data_muse
src/get_data_muse.cpp
)
target_include_directories (
get_data_muse PUBLIC
${brainflow_INCLUDE_DIRS}
)
target_link_libraries (
get_data_muse PUBLIC
# for some systems(ubuntu for example) order matters
${BrainflowPath}
${MLModulePath}
${DataHandlerPath}
${BoardControllerPath}
)
add_executable (
multiple_streamers
src/multiple_streamers.cpp
)
target_include_directories (
multiple_streamers PUBLIC
${brainflow_INCLUDE_DIRS}
)
target_link_libraries (
multiple_streamers PUBLIC
# for some systems(ubuntu for example) order matters
${BrainflowPath}
${MLModulePath}
${DataHandlerPath}
${BoardControllerPath}
)
C++ Read Data from a Board¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
using namespace std;
bool parse_args (int argc, char *argv[], struct BrainFlowInputParams *params, int *board_id);
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
BoardShim::get_board_presets (-1);
struct BrainFlowInputParams params;
int board_id = 0;
if (!parse_args (argc, argv, ¶ms, &board_id))
{
return -1;
}
int res = 0;
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_current_board_data (10);
board->release_session ();
std::cout << data << std::endl;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
bool parse_args (int argc, char *argv[], struct BrainFlowInputParams *params, int *board_id)
{
bool board_id_found = false;
for (int i = 1; i < argc; i++)
{
if (std::string (argv[i]) == std::string ("--board-id"))
{
if (i + 1 < argc)
{
i++;
board_id_found = true;
*board_id = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-address"))
{
if (i + 1 < argc)
{
i++;
params->ip_address = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-address-aux"))
{
if (i + 1 < argc)
{
i++;
params->ip_address_aux = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-address-anc"))
{
if (i + 1 < argc)
{
i++;
params->ip_address_anc = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-port"))
{
if (i + 1 < argc)
{
i++;
params->ip_port = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-port-aux"))
{
if (i + 1 < argc)
{
i++;
params->ip_port_aux = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-port-anc"))
{
if (i + 1 < argc)
{
i++;
params->ip_port_anc = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--serial-port"))
{
if (i + 1 < argc)
{
i++;
params->serial_port = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-protocol"))
{
if (i + 1 < argc)
{
i++;
params->ip_protocol = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--timeout"))
{
if (i + 1 < argc)
{
i++;
params->timeout = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--other-info"))
{
if (i + 1 < argc)
{
i++;
params->other_info = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--mac-address"))
{
if (i + 1 < argc)
{
i++;
params->mac_address = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--serial-number"))
{
if (i + 1 < argc)
{
i++;
params->serial_number = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--file"))
{
if (i + 1 < argc)
{
i++;
params->file = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--file-aux"))
{
if (i + 1 < argc)
{
i++;
params->file_aux = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--file-anc"))
{
if (i + 1 < argc)
{
i++;
params->file_anc = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--master-board"))
{
if (i + 1 < argc)
{
i++;
params->master_board = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
}
if (!board_id_found)
{
std::cerr << "board id is not provided" << std::endl;
return false;
}
return true;
}
C++ Markers¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
using namespace std;
bool parse_args (int argc, char *argv[], struct BrainFlowInputParams *params, int *board_id);
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int board_id = 0;
if (!parse_args (argc, argv, ¶ms, &board_id))
{
return -1;
}
int res = 0;
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
for (int i = 1; i < 5; i++)
{
board->insert_marker (i);
#ifdef _WIN32
Sleep (2000);
#else
sleep (2);
#endif
}
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_board_data ();
board->release_session ();
std::cout << data << std::endl;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
bool parse_args (int argc, char *argv[], struct BrainFlowInputParams *params, int *board_id)
{
bool board_id_found = false;
for (int i = 1; i < argc; i++)
{
if (std::string (argv[i]) == std::string ("--board-id"))
{
if (i + 1 < argc)
{
i++;
board_id_found = true;
*board_id = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-address"))
{
if (i + 1 < argc)
{
i++;
params->ip_address = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-port"))
{
if (i + 1 < argc)
{
i++;
params->ip_port = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--serial-port"))
{
if (i + 1 < argc)
{
i++;
params->serial_port = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-protocol"))
{
if (i + 1 < argc)
{
i++;
params->ip_protocol = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--timeout"))
{
if (i + 1 < argc)
{
i++;
params->timeout = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--other-info"))
{
if (i + 1 < argc)
{
i++;
params->other_info = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--mac-address"))
{
if (i + 1 < argc)
{
i++;
params->mac_address = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--serial-number"))
{
if (i + 1 < argc)
{
i++;
params->serial_number = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--file"))
{
if (i + 1 < argc)
{
i++;
params->file = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--master-board"))
{
if (i + 1 < argc)
{
i++;
params->master_board = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
}
if (!board_id_found)
{
std::cerr << "board id is not provided" << std::endl;
return false;
}
return true;
}
C++ Read Write File¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int res = 0;
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
// use synthetic board for demo
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_current_board_data (10);
board->release_session ();
std::cout << "Original data:" << std::endl << data << std::endl;
DataFilter::write_file (data, "test.csv", "w");
BrainFlowArray<double, 2> restored_data = DataFilter::read_file ("test.csv");
std::cout << "Restored data:" << std::endl << restored_data << std::endl;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
C++ Downsample Data¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
void print_one_row (double *data, int num_data_points);
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int res = 0;
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
// use synthetic board for demo
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_board_data ();
board->release_session ();
double *downsampled_data = NULL;
int filtered_size = 0;
std::vector<int> eeg_channels = BoardShim::get_eeg_channels (board_id);
for (int i = 0; i < eeg_channels.size (); i++)
{
std::cout << "Data from :" << eeg_channels[i] << " before downsampling " << std::endl;
print_one_row (data.get_address (eeg_channels[i]), data.get_size (1));
// just for demo apply different downsampling algorithms to different channels
// downsampling here just aggregates data points
switch (i)
{
case 0:
downsampled_data =
DataFilter::perform_downsampling (data.get_address (eeg_channels[i]),
data.get_size (1), 2, (int)AggOperations::MEAN, &filtered_size);
break;
case 1:
downsampled_data =
DataFilter::perform_downsampling (data.get_address (eeg_channels[i]),
data.get_size (1), 3, (int)AggOperations::MEDIAN, &filtered_size);
break;
default:
downsampled_data =
DataFilter::perform_downsampling (data.get_address (eeg_channels[i]),
data.get_size (1), 2, (int)AggOperations::EACH, &filtered_size);
break;
}
std::cout << "Data from :" << eeg_channels[i] << " after downsampling " << std::endl;
print_one_row (downsampled_data, filtered_size);
delete[] downsampled_data;
}
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
void print_one_row (double *data, int num_data_points)
{
// print only first 10 data points
int num_points = (num_data_points < 10) ? num_data_points : 10;
for (int i = 0; i < num_points; i++)
{
std::cout << data[i] << " ";
}
std::cout << std::endl;
}
C++ Transforms¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
void print_one_row (double *data, int num_data_points);
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int res = 0;
// use synthetic board for demo
BoardShim *board = new BoardShim ((int)BoardIds::SYNTHETIC_BOARD, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (10000);
#else
sleep (10);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_current_board_data (128);
board->release_session ();
std::cout << "Original data:" << std::endl << data << std::endl;
// apply filters
int sampling_rate = BoardShim::get_sampling_rate ((int)BoardIds::SYNTHETIC_BOARD);
std::vector<int> eeg_channels =
BoardShim::get_eeg_channels ((int)BoardIds::SYNTHETIC_BOARD);
int data_count = data.get_size (1);
for (int i = 0; i < eeg_channels.size (); i++)
{
// demo for wavelet transform
// std::pair of coeffs array in format[A(J) D(J) D(J-1) ..... D(1)] where J is a
// decomposition level, A - app coeffs, D - detailed coeffs, and array which stores
// length for each block, len of this array is decomposition_length + 1
std::pair<double *, int *> wavelet_output = DataFilter::perform_wavelet_transform (
data.get_address (eeg_channels[i]), data_count, (int)WaveletTypes::DB3, 3);
// you can do smth with wavelet coeffs here, for example denoising works via thresholds
// for wavelet coefficients
std::cout << "approximation coefficients:" << std::endl;
for (int i = 0; i < wavelet_output.second[0]; i++)
{
std::cout << wavelet_output.first[i] << " ";
}
std::cout << std::endl;
std::cout << "first block of detailed coefficients:" << std::endl;
for (int i = wavelet_output.second[0];
i < wavelet_output.second[0] + wavelet_output.second[1]; i++)
{
std::cout << wavelet_output.first[i] << " ";
}
std::cout << std::endl;
double *restored_data = DataFilter::perform_inverse_wavelet_transform (
wavelet_output, data_count, (int)WaveletTypes::DB3, 3);
std::cout << "Original data:" << std::endl;
print_one_row (data.get_address (eeg_channels[i]), data_count);
std::cout << "Restored after inverse wavelet transform data:" << std::endl;
print_one_row (restored_data, data_count);
delete[] wavelet_output.first;
delete[] restored_data;
delete[] wavelet_output.second;
// demo for fft
// data count must be power of 2 for fft!
int fft_len = 0;
std::complex<double> *fft_data =
DataFilter::perform_fft (data.get_address (eeg_channels[i]), data_count,
(int)WindowOperations::NO_WINDOW, &fft_len);
std::cout << "FFT coeffs:" << std::endl;
for (int i = 0; i < fft_len; i++)
{
std::cout << fft_data[i] << " ";
}
std::cout << std::endl;
int restored_len = 0;
double *restored_from_fft_data =
DataFilter::perform_ifft (fft_data, fft_len, &restored_len);
std::cout << "Restored after inverse fft transform data:" << std::endl;
print_one_row (restored_from_fft_data, data_count);
delete[] fft_data;
delete[] restored_from_fft_data;
}
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
void print_one_row (double *data, int num_data_points)
{
for (int i = 0; i < num_data_points; i++)
{
std::cout << data[i] << " ";
}
std::cout << std::endl;
}
C++ Signal Filtering¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int res = 0;
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
// use synthetic board for demo
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_board_data ();
board->release_session ();
std::cout << "Original data:" << std::endl << data << std::endl;
// apply filters
int sampling_rate = BoardShim::get_sampling_rate ((int)BoardIds::SYNTHETIC_BOARD);
std::vector<int> eeg_channels = BoardShim::get_eeg_channels (board_id);
for (int i = 0; i < eeg_channels.size (); i++)
{
switch (i)
{
// just for test and demo - apply different filters to different eeg channels
// signal filtering methods work in-place
case 0:
DataFilter::perform_lowpass (data.get_address (eeg_channels[i]),
data.get_size (1), BoardShim::get_sampling_rate (board_id), 50.0, 3,
(int)FilterTypes::BUTTERWORTH_ZERO_PHASE, 0);
break;
case 1:
DataFilter::perform_highpass (data.get_address (eeg_channels[i]),
data.get_size (1), BoardShim::get_sampling_rate (board_id), 3.0, 5,
(int)FilterTypes::CHEBYSHEV_TYPE_1_ZERO_PHASE, 1);
break;
case 2:
DataFilter::perform_bandpass (data.get_address (eeg_channels[i]),
data.get_size (1), BoardShim::get_sampling_rate (board_id), 3.0, 45.0, 3,
(int)FilterTypes::BESSEL_ZERO_PHASE, 0);
break;
case 3:
DataFilter::perform_bandstop (data.get_address (eeg_channels[i]),
data.get_size (1), BoardShim::get_sampling_rate (board_id), 48.0, 62.0, 4,
(int)FilterTypes::BUTTERWORTH, 0);
break;
default:
DataFilter::remove_environmental_noise (data.get_address (eeg_channels[i]),
data.get_size (1), BoardShim::get_sampling_rate (board_id),
(int)NoiseTypes::FIFTY);
break;
}
}
std::cout << "Filtered data:" << std::endl << data << std::endl;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
C++ Denoising¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int res = 0;
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
// use synthetic board for demo
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_board_data ();
board->release_session ();
std::cout << "Original data:" << std::endl << data << std::endl;
// apply filters
std::vector<int> eeg_channels = BoardShim::get_eeg_channels (board_id);
for (int i = 0; i < eeg_channels.size (); i++)
{
switch (i)
{
// for demo apply different methods to different channels
case 0:
DataFilter::perform_rolling_filter (data.get_address (eeg_channels[i]),
data.get_size (1), 3, (int)AggOperations::MEDIAN);
break;
case 1:
DataFilter::perform_rolling_filter (data.get_address (eeg_channels[i]),
data.get_size (1), 3, (int)AggOperations::MEAN);
break;
default:
// if moving average and moving median dont work well for your signal you can
// try wavelet based denoising, feel free to try different wavelet functions and
// decomposition levels
DataFilter::perform_wavelet_denoising (data.get_address (eeg_channels[i]),
data.get_size (1), (int)WaveletTypes::BIOR3_9, 3,
(int)WaveletDenoisingTypes::SURESHRINK, (int)ThresholdTypes::HARD,
(int)WaveletExtensionTypes::SYMMETRIC,
(int)NoiseEstimationLevelTypes::FIRST_LEVEL);
break;
}
}
std::cout << "Data after denoising:" << std::endl << data << std::endl;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
C++ Band Power¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int res = 0;
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
// use synthetic board for demo
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (10000);
#else
sleep (10);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_board_data ();
board->release_session ();
std::cout << "Original data:" << std::endl << data << std::endl;
// calc band powers
json board_descr = BoardShim::get_board_descr (board_id);
int sampling_rate = (int)board_descr["sampling_rate"];
int fft_len = DataFilter::get_nearest_power_of_two (sampling_rate);
std::vector<int> eeg_channels = board_descr["eeg_channels"];
// for synthetic board second channel is a sine wave at 10 Hz, should see big alpha
int channel = eeg_channels[1];
// optional - detrend
DataFilter::detrend (
data.get_address (channel), data.get_size (1), (int)DetrendOperations::LINEAR);
std::cout << "Data after detrend:" << std::endl << data << std::endl;
int psd_len = 0;
std::pair<double *, double *> psd =
DataFilter::get_psd_welch (data.get_address (channel), data.get_size (1), fft_len,
fft_len / 2, sampling_rate, (int)WindowOperations::HANNING, &psd_len);
// calc band power
double band_power_alpha = DataFilter::get_band_power (psd, psd_len, 7.0, 13.0);
double band_power_beta = DataFilter::get_band_power (psd, psd_len, 14.0, 30.0);
std::cout << "alpha/beta:" << band_power_alpha / band_power_beta << std::endl;
delete[] psd.first;
delete[] psd.second;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
C++ EEG Metrics¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
#include "ml_model.h"
using namespace std;
bool parse_args (int argc, char *argv[], struct BrainFlowInputParams *params, int *board_id);
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int board_id = 0;
if (!parse_args (argc, argv, ¶ms, &board_id))
{
return -1;
}
int res = 0;
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data = board->get_board_data ();
board->release_session ();
std::cout << data << std::endl;
// calc band powers
int sampling_rate = BoardShim::get_sampling_rate ((int)BoardIds::SYNTHETIC_BOARD);
std::vector<int> eeg_channels = BoardShim::get_eeg_channels (board_id);
std::pair<double *, double *> bands =
DataFilter::get_avg_band_powers (data, eeg_channels, sampling_rate, true);
struct BrainFlowModelParams mindfulness_params (
(int)BrainFlowMetrics::MINDFULNESS, (int)BrainFlowClassifiers::DEFAULT_CLASSIFIER);
MLModel mindfulness_model (mindfulness_params);
mindfulness_model.prepare ();
std::cout << "Mindfulness :" << mindfulness_model.predict (bands.first, 5)[0] << std::endl;
mindfulness_model.release ();
struct BrainFlowModelParams restfulness_params (
(int)BrainFlowMetrics::RESTFULNESS, (int)BrainFlowClassifiers::DEFAULT_CLASSIFIER);
MLModel restfulness_model (restfulness_params);
restfulness_model.prepare ();
std::cout << "Restfulness :" << restfulness_model.predict (bands.first, 5)[0] << std::endl;
restfulness_model.release ();
delete[] bands.first;
delete[] bands.second;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
bool parse_args (int argc, char *argv[], struct BrainFlowInputParams *params, int *board_id)
{
bool board_id_found = false;
for (int i = 1; i < argc; i++)
{
if (std::string (argv[i]) == std::string ("--board-id"))
{
if (i + 1 < argc)
{
i++;
board_id_found = true;
*board_id = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-address"))
{
if (i + 1 < argc)
{
i++;
params->ip_address = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-port"))
{
if (i + 1 < argc)
{
i++;
params->ip_port = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--serial-port"))
{
if (i + 1 < argc)
{
i++;
params->serial_port = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--ip-protocol"))
{
if (i + 1 < argc)
{
i++;
params->ip_protocol = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--timeout"))
{
if (i + 1 < argc)
{
i++;
params->timeout = std::stoi (std::string (argv[i]));
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--other-info"))
{
if (i + 1 < argc)
{
i++;
params->other_info = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--mac-address"))
{
if (i + 1 < argc)
{
i++;
params->mac_address = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--serial-number"))
{
if (i + 1 < argc)
{
i++;
params->serial_number = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
if (std::string (argv[i]) == std::string ("--file"))
{
if (i + 1 < argc)
{
i++;
params->file = std::string (argv[i]);
}
else
{
std::cerr << "missed argument" << std::endl;
return false;
}
}
}
if (!board_id_found)
{
std::cerr << "board id is not provided" << std::endl;
return false;
}
return true;
}
C++ ICA¶
#include <iostream>
#include <stdlib.h>
#include <string>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
int main (int argc, char *argv[])
{
BoardShim::enable_dev_board_logger ();
struct BrainFlowInputParams params;
int res = 0;
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
std::vector<int> eeg_channels = BoardShim::get_eeg_channels (board_id);
int channel_to_use = eeg_channels[4];
// use synthetic board for demo
BoardShim *board = new BoardShim (board_id, params);
try
{
board->prepare_session ();
board->start_stream ();
#ifdef _WIN32
Sleep (10000);
#else
sleep (10);
#endif
board->stop_stream ();
BrainFlowArray<double, 2> data =
board->get_board_data (500, (int)BrainFlowPresets::DEFAULT_PRESET);
board->release_session ();
BrainFlowArray<double, 2> data_reshaped (data.get_address (channel_to_use), 5, 100);
std::tuple<BrainFlowArray<double, 2>, BrainFlowArray<double, 2>, BrainFlowArray<double, 2>,
BrainFlowArray<double, 2>>
returned_matrixes = DataFilter::perform_ica (data_reshaped, 2);
std::cout << std::get<3> (returned_matrixes) << std::endl;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
delete board;
return res;
}
R¶
R Get Data from a Board¶
library(brainflow)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(brainflow_python$BoardIds$SYNTHETIC_BOARD$value, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 5)
board_shim$stop_stream()
data <- board_shim$get_current_board_data(as.integer(250))
board_shim$release_session()
R Get Data from a Board¶
library(brainflow)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(brainflow_python$BoardIds$SYNTHETIC_BOARD$value, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 5)
board_shim$insert_marker(1)
board_shim$stop_stream()
data <- board_shim$get_current_board_data(as.integer(250))
board_shim$release_session()
R Read Write File¶
library(brainflow)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(brainflow_python$BoardIds$SYNTHETIC_BOARD$value, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 5)
board_shim$stop_stream()
data <- board_shim$get_current_board_data(as.integer(250))
data <- np$ascontiguousarray(data)
board_shim$release_session()
brainflow_python$DataFilter$write_file(data, "test.csv", "w")
data_restored <- brainflow_python$DataFilter$read_file("test.csv")
print(data_restored)
R Transforms¶
library(brainflow)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(brainflow_python$BoardIds$SYNTHETIC_BOARD$value, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 5)
board_shim$stop_stream()
data <- board_shim$get_current_board_data(as.integer(250))
board_shim$release_session()
# need to convert to numpy array manually
numpy_data <- np$array(data[2,])
print(numpy_data)
wavelet_data <- brainflow_python$DataFilter$perform_wavelet_transform(numpy_data, "db4", as.integer(3))
restored_data <- brainflow_python$DataFilter$perform_inverse_wavelet_transform(wavelet_data, length(numpy_data), "db4", as.integer(3))
print(restored_data)
R Signal Filtering¶
library(brainflow)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(brainflow_python$BoardIds$SYNTHETIC_BOARD$value, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 5)
board_shim$stop_stream()
data <- board_shim$get_current_board_data(as.integer(250))
board_shim$release_session()
# need to convert to numpy array manually
numpy_data <- np$array(data[2,])
print(numpy_data)
sampling_rate <- board_shim$get_sampling_rate(brainflow_python$BoardIds$SYNTHETIC_BOARD$value)
brainflow_python$DataFilter$perform_bandpass(numpy_data, sampling_rate, 10.0, 5.0, as.integer(3), brainflow_python$FilterTypes$BESSEL$value, 0)
print(numpy_data)
R Denoising¶
library(brainflow)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(brainflow_python$BoardIds$SYNTHETIC_BOARD$value, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 5)
board_shim$stop_stream()
data <- board_shim$get_current_board_data(as.integer(250))
board_shim$release_session()
# need to convert to numpy array manually
numpy_data <- np$array(data[2,])
print(numpy_data)
brainflow_python$DataFilter$perform_wavelet_denoising(numpy_data, "db4", as.integer(3))
print(numpy_data)
R Band Power¶
library(brainflow)
board_id <- brainflow_python$BoardIds$SYNTHETIC_BOARD$value
sampling_rate <- brainflow_python$BoardShim$get_sampling_rate(board_id)
nfft <- brainflow_python$DataFilter$get_nearest_power_of_two(sampling_rate)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(board_id, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 10)
board_shim$stop_stream()
data <- board_shim$get_board_data()
board_shim$release_session()
# need to convert to numpy array manually
numpy_data <- np$array(data[3,])
psd <- brainflow_python$DataFilter$get_psd_welch(numpy_data, as.integer(nfft), as.integer(nfft / 2),
sampling_rate, brainflow_python$WindowOperations$BLACKMAN_HARRIS$value)
band_power_alpha <- brainflow_python$DataFilter$get_band_power(psd, 7.0, 13.0)
band_power_beta <- brainflow_python$DataFilter$get_band_power(psd, 14.0, 30.0)
ratio <- band_power_alpha / band_power_beta
R EEG Metrics¶
library(brainflow)
board_id <- brainflow_python$BoardIds$SYNTHETIC_BOARD$value
sampling_rate <- brainflow_python$BoardShim$get_sampling_rate(board_id)
nfft <- brainflow_python$DataFilter$get_nearest_power_of_two(sampling_rate)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(board_id, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 10)
board_shim$stop_stream()
data <- board_shim$get_board_data()
board_shim$release_session()
eeg_channels <- brainflow_python$BoardShim$get_eeg_channels(board_id)
data <- np$ascontiguousarray(data)
eeg_channels <- np$ascontiguousarray(c(eeg_channels))
bands <- brainflow_python$DataFilter$get_avg_band_powers(data, eeg_channels, sampling_rate, TRUE)
feature_vector <- np$array(bands[[1]])
model_params <- brainflow_python$BrainFlowModelParams(brainflow_python$BrainFlowMetrics$MINDFULNESS$value, brainflow_python$BrainFlowClassifiers$DEFAULT_CLASSIFIER$value)
model <- brainflow_python$MLModel(model_params)
model$prepare()
score <- model$predict(feature_vector)
model$release()
R ICA¶
library(brainflow)
params <- brainflow_python$BrainFlowInputParams()
board_shim <- brainflow_python$BoardShim(brainflow_python$BoardIds$SYNTHETIC_BOARD$value, params)
board_shim$prepare_session()
board_shim$start_stream()
Sys.sleep(time = 10)
board_shim$stop_stream()
data <- board_shim$get_board_data(as.integer(500))
board_shim$release_session()
eeg_channels <- brainflow_python$BoardShim$get_eeg_channels(as.integer(-1))
my_channel = eeg_channels[2]
numpy_data <- np$array(data[my_channel,])
numpy_data <- numpy_data$reshape(as.integer(5),as.integer(100))
ica <- brainflow_python$DataFilter$perform_ica(numpy_data, as.integer(2))
Matlab¶
Matlab Get Data from a Board¶
BoardShim.set_log_file('brainflow.log');
BoardShim.enable_dev_board_logger();
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
board_shim.prepare_session();
board_shim.add_streamer('file://data_default.csv:w', preset);
board_shim.start_stream(45000, '');
pause(5);
board_shim.stop_stream();
data = board_shim.get_current_board_data(10, preset);
disp(data);
board_shim.release_session();
Matlab Markers¶
BoardShim.set_log_file('brainflow.log');
BoardShim.enable_dev_board_logger();
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
board_shim.prepare_session();
board_shim.start_stream(45000, '');
pause(2);
board_shim.insert_marker(1, preset);
pause(2);
board_shim.stop_stream();
data = board_shim.get_board_data(board_shim.get_board_data_count(preset), preset);
disp(data);
board_shim.release_session();
Matlab Read Write File¶
BoardShim.set_log_file('brainflow.log');
BoardShim.enable_dev_board_logger();
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
board_shim.prepare_session();
board_shim.start_stream(45000, '');
pause(2)
board_shim.stop_stream()
data = board_shim.get_current_board_data(20, preset);
board_shim.release_session();
DataFilter.write_file(data, 'data.csv', 'w');
restored_data = DataFilter.read_file('data.csv');
Matlab Transforms¶
BoardShim.set_log_file('brainflow.log');
BoardShim.enable_dev_board_logger();
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
sampling_rate = BoardShim.get_sampling_rate(int32(BoardIds.SYNTHETIC_BOARD), preset);
board_shim.prepare_session();
board_shim.start_stream(45000, '');
pause(5);
board_shim.stop_stream();
data = board_shim.get_current_board_data(256, preset);
board_shim.release_session();
eeg_channels = BoardShim.get_eeg_channels(int32(BoardIds.SYNTHETIC_BOARD), preset);
% wavelet for first eeg channel %
first_eeg_channel = eeg_channels(1);
original_data = data(first_eeg_channel, :);
[wavelet_data, wavelet_lenghts] = DataFilter.perform_wavelet_transform(original_data, int32(WaveletTypes.DB3), 3, int32(WaveletExtensionTypes.SYMMETRIC));
restored_data = DataFilter.perform_inverse_wavelet_transform(wavelet_data, wavelet_lenghts, size(original_data, 2), int32(WaveletTypes.DB3), 3, int32(WaveletExtensionTypes.SYMMETRIC));
% fft for first eeg channel %
fft_data = DataFilter.perform_fft(original_data, int32(WindowOperations.NO_WINDOW));
restored_fft_data = DataFilter.perform_ifft(fft_data);
Matlab Signal Filtering¶
BoardShim.set_log_file('brainflow.log');
BoardShim.enable_dev_board_logger();
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
board_shim.prepare_session();
board_shim.start_stream(45000, '');
pause(5);
board_shim.stop_stream();
data = board_shim.get_current_board_data(64, preset);
board_shim.release_session();
eeg_channels = BoardShim.get_eeg_channels(int32(BoardIds.SYNTHETIC_BOARD), preset);
% apply iir filter to the first eeg channel %
first_eeg_channel = eeg_channels(1);
original_data = data(first_eeg_channel, :);
sampling_rate = BoardShim.get_sampling_rate(int32(BoardIds.SYNTHETIC_BOARD), preset);
filtered_data = DataFilter.perform_lowpass(original_data, sampling_rate, 50.0, 3, int32(FilterTypes.BUTTERWORTH), 0.0);
Matlab Denoising¶
BoardShim.set_log_file('brainflow.log');
BoardShim.enable_dev_board_logger();
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
board_shim.prepare_session();
board_shim.start_stream(45000, '');
pause(5);
board_shim.stop_stream();
data = board_shim.get_current_board_data(64, preset);
board_shim.release_session();
eeg_channels = BoardShim.get_eeg_channels(int32(BoardIds.SYNTHETIC_BOARD), preset);
% apply wavelet denoising to the first eeg channel %
first_eeg_channel = eeg_channels(1);
noisy_data = data(first_eeg_channel, :);
denoised_data = DataFilter.perform_wavelet_denoising(noisy_data, int32(WaveletTypes.DB3), 3, int32(WaveletDenoisingTypes.SURESHRINK), int32(ThresholdTypes.HARD), int32(WaveletExtensionTypes.SYMMETRIC), int32(NoiseEstimationLevelTypes.FIRST_LEVEL));
Matlab Band Power¶
BoardShim.enable_dev_board_logger();
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
board_id = int32(BoardIds.SYNTHETIC_BOARD);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
board_descr = BoardShim.get_board_descr(board_id, preset);
sampling_rate = int32(board_descr.sampling_rate);
board_shim.prepare_session();
board_shim.start_stream(45000, '');
pause(10);
board_shim.stop_stream();
nfft = DataFilter.get_nearest_power_of_two(sampling_rate);
data = board_shim.get_board_data(board_shim.get_board_data_count(preset), preset);
board_shim.release_session();
eeg_channels = board_descr.eeg_channels;
eeg_channel = eeg_channels(3);
original_data = data(eeg_channel, :);
detrended = DataFilter.detrend(original_data, int32(DetrendOperations.LINEAR));
[ampls, freqs] = DataFilter.get_psd_welch(detrended, nfft, nfft / 2, sampling_rate, int32(WindowOperations.HANNING));
band_power_alpha = DataFilter.get_band_power(ampls, freqs, 7.0, 13.0);
band_power_beta = DataFilter.get_band_power(ampls, freqs, 14.0, 30.0);
ratio = band_power_alpha / band_power_beta;
Matlab EEG Metrics¶
BoardShim.set_log_file('brainflow.log');
MLModel.set_log_file('brainflow_ml.log');
BoardShim.enable_dev_board_logger();
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
sampling_rate = BoardShim.get_sampling_rate(int32(BoardIds.SYNTHETIC_BOARD), preset);
board_shim.prepare_session();
board_shim.start_stream(45000, '');
pause(5);
board_shim.stop_stream();
nfft = DataFilter.get_nearest_power_of_two(sampling_rate);
data = board_shim.get_board_data(board_shim.get_board_data_count(preset), preset);
board_shim.release_session();
eeg_channels = BoardShim.get_eeg_channels(int32(BoardIds.SYNTHETIC_BOARD), preset);
[avgs, stddevs] = DataFilter.get_avg_band_powers(data, eeg_channels, sampling_rate, true);
feature_vector = avgs;
model_params = BrainFlowModelParams(int32(BrainFlowMetrics.RESTFULNESS), int32(BrainFlowClassifiers.DEFAULT_CLASSIFIER));
model = MLModel(model_params);
model.prepare();
score = model.predict(feature_vector);
model.release();
Matlab ICA¶
params = BrainFlowInputParams();
board_shim = BoardShim(int32(BoardIds.SYNTHETIC_BOARD), params);
preset = int32(BrainFlowPresets.DEFAULT_PRESET);
board_shim.prepare_session();
board_shim.start_stream(45000, '');
pause(10);
board_shim.stop_stream();
data = board_shim.get_board_data(500, preset);
board_shim.release_session();
eeg_channels = BoardShim.get_eeg_channels(int32(BoardIds.SYNTHETIC_BOARD), preset);
selected_channel = eeg_channels(4);
original_data = data(selected_channel, :);
original_data = transpose(reshape(original_data, [100, 5]));
[w,k,a,s] = DataFilter.perform_ica(original_data, 2);
Julia¶
Julia Get Data from a Board¶
using BrainFlow
# specify logging library to use
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
BrainFlow.prepare_session(board_shim)
BrainFlow.start_stream(board_shim)
sleep(5)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_current_board_data(256, board_shim)
BrainFlow.release_session(board_shim)
Julia Markers¶
using BrainFlow
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
BrainFlow.prepare_session(board_shim)
BrainFlow.start_stream(board_shim, 45000, "file://data.csv:w")
sleep(1)
BrainFlow.insert_marker(1.0, board_shim)
sleep(1)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_current_board_data(256, board_shim)
BrainFlow.release_session(board_shim)
Julia Read Write File¶
using BrainFlow
# specify logging library to use
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
BrainFlow.prepare_session(board_shim)
BrainFlow.add_streamer("file://data_default.csv:w", board_shim)
BrainFlow.start_stream(board_shim)
sleep(5)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_current_board_data(32, board_shim)
BrainFlow.release_session(board_shim)
BrainFlow.write_file(data, "test.csv", "w")
restored_data = BrainFlow.read_file("test.csv")
println("Original Data")
println(data)
println("Restored Data")
println(restored_data)
Julia Transforms¶
using BrainFlow
# enable logs
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
BrainFlow.enable_dev_logger(BrainFlow.DATA_HANDLER)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
sampling_rate = BrainFlow.get_sampling_rate(BrainFlow.SYNTHETIC_BOARD)
BrainFlow.prepare_session(board_shim)
BrainFlow.start_stream(board_shim)
sleep(10)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_current_board_data(256, board_shim)
BrainFlow.release_session(board_shim)
eeg_channels = BrainFlow.get_eeg_channels(BrainFlow.SYNTHETIC_BOARD)
data_first_channel = data[eeg_channels[1], :]
# returns tuple of wavelet coeffs and lengths
wavelet_data = BrainFlow.perform_wavelet_transform(data_first_channel, BrainFlow.DB3, 2, BrainFlow.SYMMETRIC)
restored_wavelet_data = BrainFlow.perform_inverse_wavelet_transform(wavelet_data, length(data_first_channel),
BrainFlow.DB3, 2, BrainFlow.SYMMETRIC)
fft_data = BrainFlow.perform_fft(data_first_channel, BrainFlow.NO_WINDOW)
restored_fft_data = BrainFlow.perform_ifft(fft_data)
println("Original Data")
println(data_first_channel)
println("Restored from Wavelet Data")
println(restored_wavelet_data)
println("Restored from FFT Data")
println(restored_fft_data)
Julia Signal Filtering¶
using BrainFlow
# specify logging library to use
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
BrainFlow.prepare_session(board_shim)
BrainFlow.start_stream(board_shim)
sleep(5)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_current_board_data(32, board_shim)
BrainFlow.release_session(board_shim)
eeg_channels = BrainFlow.get_eeg_channels(BrainFlow.SYNTHETIC_BOARD)
sampling_rate = BrainFlow.get_sampling_rate(BrainFlow.SYNTHETIC_BOARD)
data_first_channel = data[eeg_channels[1], :]
println("Original Data First Channel")
println(data_first_channel)
BrainFlow.perform_lowpass(data_first_channel, sampling_rate, 50.0, 3, BrainFlow.BUTTERWORTH, 0.0)
println("After LowPass Filter")
println(data_first_channel)
data_second_channel = data[eeg_channels[2], :]
println("Original Data Second Channel")
println(data_second_channel)
BrainFlow.perform_highpass(data_second_channel, sampling_rate, 3.0, 3, BrainFlow.CHEBYSHEV_TYPE_1, 1.0)
println("After HighPass Filter")
println(data_second_channel)
data_third_channel = data[eeg_channels[3], :]
println("Original Data Third Channel")
println(data_third_channel)
BrainFlow.perform_bandpass(data_third_channel, sampling_rate, 3.0, 50.0, 3, BrainFlow.BESSEL, 0.0)
println("After BandPass Filter")
println(data_third_channel)
data_fourth_channel = data[eeg_channels[4], :]
println("Original Data Fourth Channel")
println(data_fourth_channel)
BrainFlow.perform_bandstop(data_fourth_channel, sampling_rate, 48.0, 52.0, 3, BrainFlow.BESSEL, 0.0)
println("After BandStop Filter")
println(data_fourth_channel)
data_fifth_channel = data[eeg_channels[5], :]
println("Original Data Fifth Channel")
println(data_fifth_channel)
BrainFlow.remove_environmental_noise(data_fifth_channel, sampling_rate, BrainFlow.FIFTY)
println("After BandStop Filter")
println(data_fifth_channel)
Julia Denoising¶
using BrainFlow
# specify logging library to use
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
BrainFlow.prepare_session(board_shim)
BrainFlow.start_stream(board_shim)
sleep(5)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_current_board_data(256, board_shim)
BrainFlow.release_session(board_shim)
eeg_channels = BrainFlow.get_eeg_channels(BrainFlow.SYNTHETIC_BOARD)
sampling_rate = BrainFlow.get_sampling_rate(BrainFlow.SYNTHETIC_BOARD)
data_first_channel = data[eeg_channels[1], :]
println("Original Data First Channel")
println(data_first_channel)
BrainFlow.perform_rolling_filter(data_first_channel, 3, BrainFlow.MEAN)
println("After Rolling Filter")
println(data_first_channel)
data_second_channel = data[eeg_channels[2], :]
println("Original Data Second Channel")
println(data_second_channel)
BrainFlow.perform_wavelet_denoising(data_second_channel, BrainFlow.BIOR3_9, 3, BrainFlow.SURESHRINK,
BrainFlow.HARD, BrainFlow.SYMMETRIC, BrainFlow.FIRST_LEVEL)
println("After Wavelet Denoising")
println(data_second_channel)
Julia Band Power¶
using BrainFlow
# specify logging library to use
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
board_descr = BrainFlow.get_board_descr(BrainFlow.SYNTHETIC_BOARD)
sampling_rate = board_descr["sampling_rate"]
nfft = BrainFlow.get_nearest_power_of_two(sampling_rate)
BrainFlow.prepare_session(board_shim)
BrainFlow.start_stream(board_shim)
sleep(5)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_board_data(board_shim)
BrainFlow.release_session(board_shim)
eeg_channels = board_descr["eeg_channels"]
# second channel of synthetic board is sine wave at 10 Hz, should see huge 'alpha'
data_second_channel = data[eeg_channels[2], :]
# optional: detrend
BrainFlow.detrend(data_second_channel, BrainFlow.LINEAR)
# psd is a tuple of ampls and freqs
psd = BrainFlow.get_psd_welch(data_second_channel, nfft, Integer(nfft / 2), sampling_rate, BrainFlow.BLACKMAN_HARRIS)
band_power_alpha = BrainFlow.get_band_power(psd, 7.0, 13.0)
band_power_beta = BrainFlow.get_band_power(psd, 14.0, 30.0)
println(band_power_alpha / band_power_beta)
Julia EEG Metrics¶
using BrainFlow
# enable all possible logs from all three libs
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
BrainFlow.enable_dev_logger(BrainFlow.DATA_HANDLER)
BrainFlow.enable_dev_logger(BrainFlow.ML_MODULE)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
sampling_rate = BrainFlow.get_sampling_rate(BrainFlow.SYNTHETIC_BOARD)
nfft = BrainFlow.get_nearest_power_of_two(sampling_rate)
BrainFlow.prepare_session(board_shim)
BrainFlow.start_stream(board_shim)
sleep(5)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_board_data(board_shim)
BrainFlow.release_session(board_shim)
eeg_channels = BrainFlow.get_eeg_channels(BrainFlow.SYNTHETIC_BOARD)
bands = BrainFlow.get_avg_band_powers(data, eeg_channels, sampling_rate, true)
feature_vector = bands[1]
println(feature_vector)
model_params = BrainFlowModelParams(BrainFlow.MINDFULNESS, BrainFlow.DEFAULT_CLASSIFIER)
BrainFlow.prepare(model_params)
print(BrainFlow.predict(feature_vector, model_params))
BrainFlow.release(model_params)
Julia ICA¶
using BrainFlow
# enable logs
BrainFlow.enable_dev_logger(BrainFlow.BOARD_CONTROLLER)
BrainFlow.enable_dev_logger(BrainFlow.DATA_HANDLER)
params = BrainFlowInputParams()
board_shim = BrainFlow.BoardShim(BrainFlow.SYNTHETIC_BOARD, params)
sampling_rate = BrainFlow.get_sampling_rate(BrainFlow.SYNTHETIC_BOARD)
BrainFlow.prepare_session(board_shim)
BrainFlow.start_stream(board_shim)
sleep(10)
BrainFlow.stop_stream(board_shim)
data = BrainFlow.get_board_data(500, board_shim)
BrainFlow.release_session(board_shim)
eeg_channels = BrainFlow.get_eeg_channels(BrainFlow.SYNTHETIC_BOARD)
data_first_channel = data[eeg_channels[1], :]
my_data = transpose(reshape(data_first_channel, (100, 5)))
ica = BrainFlow.perform_ica(my_data, 2)
Rust¶
Rust Get Data from a Board¶
use std::{thread, time::Duration};
use brainflow::{board_shim, brainflow_input_params::BrainFlowInputParamsBuilder, BoardIds, BrainFlowPresets,};
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let params = BrainFlowInputParamsBuilder::default().build();
let board = board_shim::BoardShim::new(BoardIds::SyntheticBoard, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "").unwrap();
thread::sleep(Duration::from_secs(5));
board.stop_stream().unwrap();
let data = board.get_board_data(Some(10), BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
println!("{}", data.len());
println!("{:?}", data);
}
Rust Markers¶
use std::thread;
use std::time::Duration;
use brainflow::board_shim::BoardShim;
use brainflow::brainflow_input_params::BrainFlowInputParamsBuilder;
use brainflow::BoardIds;
use brainflow::BrainFlowPresets;
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let params = BrainFlowInputParamsBuilder::default().build();
let board = BoardShim::new(BoardIds::SyntheticBoard, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "file://data.csv:w").unwrap();
thread::sleep(Duration::from_secs(5));
board.insert_marker(1.0, BrainFlowPresets::DefaultPreset).unwrap();
thread::sleep(Duration::from_secs(5));
board.stop_stream().unwrap();
let data = board.get_board_data(Some(10), BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
println!("{:?}", data);
}
Rust Read Write File¶
use std::{env, fs, thread, time::Duration};
use brainflow::{
board_shim, brainflow_input_params::BrainFlowInputParamsBuilder, data_filter, BoardIds, BrainFlowPresets,
};
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let params = BrainFlowInputParamsBuilder::default().build();
let board = board_shim::BoardShim::new(BoardIds::SyntheticBoard, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "").unwrap();
thread::sleep(Duration::from_secs(5));
board.stop_stream().unwrap();
let data = board.get_board_data(Some(10), BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
let mut tmp_dir = env::temp_dir();
tmp_dir.push("brainflow_tests");
tmp_dir.push("rust");
fs::create_dir_all(&tmp_dir).unwrap();
tmp_dir.push("read-write_file.csv");
let filename = tmp_dir.to_str().unwrap();
dbg!(&data);
data_filter::write_file(&data, filename, "w").unwrap();
let read_data = data_filter::read_file(filename).unwrap();
dbg!(read_data);
}
Rust Transforms¶
use std::{thread, time::Duration};
use brainflow::{
board_shim, brainflow_input_params::BrainFlowInputParamsBuilder, data_filter, BoardIds,
WindowOperations, WaveletTypes, WaveletExtensionTypes, BrainFlowPresets,
};
use ndarray::s;
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let board_id = BoardIds::SyntheticBoard;
let eeg_channels = board_shim::get_eeg_channels(board_id, BrainFlowPresets::DefaultPreset).unwrap();
println!("{:?}", eeg_channels);
let params = BrainFlowInputParamsBuilder::default().build();
let board = board_shim::BoardShim::new(board_id, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "").unwrap();
thread::sleep(Duration::from_secs(5));
board.stop_stream().unwrap();
let mut data = board.get_board_data(Some(64), BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
let data_len = data.slice(s![0, ..]).len();
let fft_data = data_filter::perform_fft(
data.slice_mut(s![eeg_channels[0], ..])
.as_slice_mut()
.unwrap(),
WindowOperations::BlackmanHarris,
)
.unwrap();
let restored_fft = data_filter::perform_ifft(&fft_data, data_len).unwrap();
println!("{:?}", restored_fft);
println!("{:?}", data.slice(s![1, ..]));
let wavelet_data = data_filter::perform_wavelet_transform(
data.slice_mut(s![eeg_channels[1], ..])
.as_slice_mut()
.unwrap(),
WaveletTypes::Db3,
3,
WaveletExtensionTypes::Symmetric,
)
.unwrap();
let restored_wavelet = data_filter::perform_inverse_wavelet_transform(wavelet_data).unwrap();
println!("{:?}", restored_wavelet);
}
Rust Signal Filtering¶
use std::{thread, time::Duration};
use brainflow::{board_shim, brainflow_input_params::BrainFlowInputParamsBuilder, BoardIds, BrainFlowPresets,};
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let params = BrainFlowInputParamsBuilder::default().build();
let board = board_shim::BoardShim::new(BoardIds::SyntheticBoard, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "").unwrap();
thread::sleep(Duration::from_secs(5));
board.stop_stream().unwrap();
let data = board.get_board_data(Some(10), BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
println!("{}", data.len());
println!("{:?}", data);
}
Rust Denoising¶
use std::{thread, time::Duration};
use brainflow::{
board_shim, brainflow_input_params::BrainFlowInputParamsBuilder, data_filter, AggOperations,
BoardIds, WaveletTypes, WaveletExtensionTypes, WaveletDenoisingTypes, ThresholdTypes, NoiseEstimationLevelTypes,
BrainFlowPresets,
};
use ndarray::s;
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let board_id = BoardIds::SyntheticBoard;
let eeg_channels = board_shim::get_eeg_channels(board_id, BrainFlowPresets::DefaultPreset).unwrap();
let params = BrainFlowInputParamsBuilder::default().build();
let board = board_shim::BoardShim::new(board_id, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "").unwrap();
board.add_streamer("file://data.csv:w", BrainFlowPresets::DefaultPreset).unwrap();
thread::sleep(Duration::from_secs(5));
board.stop_stream().unwrap();
let mut data = board.get_board_data(Some(128), BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
println!("{:?}", data.slice(s![eeg_channels[0], ..]));
data_filter::perform_rolling_filter(
data.slice_mut(s![eeg_channels[0], ..])
.as_slice_mut()
.unwrap(),
3,
AggOperations::Mean,
)
.unwrap();
println!("{:?}", data.slice(s![eeg_channels[0], ..]));
println!("{:?}", data.slice(s![eeg_channels[1], ..]));
data_filter::perform_wavelet_denoising(
data.slice_mut(s![eeg_channels[1], ..])
.as_slice_mut()
.unwrap(),
WaveletTypes::Db3,
3,
WaveletDenoisingTypes::Sureshrink,
ThresholdTypes::Hard,
WaveletExtensionTypes::Symmetric,
NoiseEstimationLevelTypes::FirstLevel,
)
.unwrap();
println!("{:?}", data.slice(s![eeg_channels[1], ..]));
}
Rust Band Power¶
use brainflow::data_filter::Band;
use std::{thread, time::Duration};
use brainflow::{
board_shim, brainflow_input_params::BrainFlowInputParamsBuilder, data_filter, BoardIds,
DetrendOperations, WindowOperations, BrainFlowPresets,
};
use ndarray::s;
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let board_id = BoardIds::SyntheticBoard;
let eeg_channels = board_shim::get_eeg_channels(board_id, BrainFlowPresets::DefaultPreset).unwrap();
let sampling_rate = board_shim::get_sampling_rate(board_id, BrainFlowPresets::DefaultPreset).unwrap();
let nfft = data_filter::get_nearest_power_of_two(sampling_rate).unwrap();
let params = BrainFlowInputParamsBuilder::default().build();
let board = board_shim::BoardShim::new(board_id, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "").unwrap();
thread::sleep(Duration::from_secs(5));
board.stop_stream().unwrap();
let mut data = board.get_board_data(None, BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
data_filter::detrend(
data.slice_mut(s![eeg_channels[1], ..])
.as_slice_mut()
.unwrap(),
DetrendOperations::Linear,
)
.unwrap();
let mut psd = data_filter::get_psd_welch(
data.slice_mut(s![eeg_channels[1], ..])
.as_slice_mut()
.unwrap(),
nfft,
nfft / 2,
sampling_rate,
WindowOperations::BlackmanHarris,
)
.unwrap();
let band_power_alpha = data_filter::get_band_power(&mut psd, Band { freq_start: 8.0, freq_stop: 13.0 }).unwrap();
let band_power_beta = data_filter::get_band_power(&mut psd, Band { freq_start: 14.0, freq_stop: 30.0 }).unwrap();
println!(
"band_power_alpha / band_power_beta = {}",
band_power_alpha / band_power_beta
);
}
Rust EEG Metrics¶
use std::{thread, time::Duration};
use brainflow::{
board_shim, brainflow_input_params::BrainFlowInputParamsBuilder,
brainflow_model_params::BrainFlowModelParamsBuilder, data_filter, ml_model, BoardIds,
BrainFlowClassifiers, BrainFlowMetrics, BrainFlowPresets,
};
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let params = BrainFlowInputParamsBuilder::default().build();
let board_id = BoardIds::SyntheticBoard;
let board = board_shim::BoardShim::new(board_id, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "").unwrap();
thread::sleep(Duration::from_secs(5));
board.stop_stream().unwrap();
let data = board.get_board_data(None, BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
let eeg_channels = board_shim::get_eeg_channels(board_id, BrainFlowPresets::DefaultPreset).unwrap();
let sampling_rate = board_shim::get_sampling_rate(board_id, BrainFlowPresets::DefaultPreset).unwrap();
let bands =
data_filter::get_avg_band_powers(data, eeg_channels, sampling_rate, true).unwrap();
let mut feature_vector = bands.0;
println!("feature_vector: {:?}", feature_vector);
let model_params = BrainFlowModelParamsBuilder::new()
.metric(BrainFlowMetrics::Mindfulness)
.classifier(BrainFlowClassifiers::DefaultClassifier)
.build();
let mindfulness = ml_model::MlModel::new(model_params).unwrap();
mindfulness.prepare().unwrap();
println!(
"Mindfulness: {:?}",
mindfulness.predict(&mut feature_vector)
);
mindfulness.release().unwrap();
}
Rust ICA¶
use ndarray::Array2;
use std::{thread, time::Duration};
use brainflow::{
board_shim, brainflow_input_params::BrainFlowInputParamsBuilder, data_filter, BoardIds, BrainFlowPresets,
};
use ndarray::s;
fn main() {
brainflow::board_shim::enable_dev_board_logger().unwrap();
let board_id = BoardIds::SyntheticBoard;
let eeg_channels = board_shim::get_eeg_channels(board_id, BrainFlowPresets::DefaultPreset).unwrap();
println!("{:?}", eeg_channels);
let params = BrainFlowInputParamsBuilder::default().build();
let board = board_shim::BoardShim::new(board_id, params).unwrap();
board.prepare_session().unwrap();
board.start_stream(45000, "").unwrap();
thread::sleep(Duration::from_secs(10));
board.stop_stream().unwrap();
let mut data = board.get_board_data(Some(500), BrainFlowPresets::DefaultPreset).unwrap();
board.release_session().unwrap();
let my_channel = eeg_channels[4];
let mut my_data = data.slice_mut(s![my_channel, ..]);
let data_my_channel = my_data.as_slice_mut().unwrap();
let ica_data = Array2::from_shape_vec((5, 100), data_my_channel.to_vec()).unwrap();
let _ica = data_filter::perform_ica(ica_data, 2).unwrap();
}
Typescript¶
Typescript Get Data from a Board¶
import {BoardIds, BoardShim} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const board = new BoardShim (BoardIds.SYNTHETIC_BOARD, {});
board.prepareSession();
board.startStream();
await sleep (3000);
board.stopStream();
const data = board.getBoardData();
board.releaseSession();
console.info('Data');
console.info(data);
}
runExample ();
Typescript Markers¶
import {BoardIds, BoardShim} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const board = new BoardShim (BoardIds.SYNTHETIC_BOARD, {});
board.prepareSession();
board.startStream();
await sleep (1000);
board.insertMarker(1);
await sleep (1000);
board.stopStream();
const data = board.getBoardData();
board.releaseSession();
console.info('Data');
console.info(data);
}
runExample ();
Typescript Read Write File¶
import {BoardIds, BoardShim, DataFilter} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const board = new BoardShim (BoardIds.SYNTHETIC_BOARD, {});
board.prepareSession();
board.startStream();
await sleep (3000);
board.stopStream();
const data = board.getCurrentBoardData(10);
board.releaseSession()
console.info('Data');
console.info(data);
DataFilter.writeFile(data, 'test.csv', 'w');
const dataRestored = DataFilter.readFile('test.csv');
console.info('Data restored');
console.info(dataRestored);
DataFilter.writeFile(dataRestored, 'test2.csv', 'w');
}
runExample ();
Typescript Downsample Data¶
import {AggOperations, BoardIds, BoardShim, DataFilter} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const boardId = BoardIds.SYNTHETIC_BOARD;
const board = new BoardShim (boardId, {});
board.prepareSession();
board.startStream();
await sleep (3000);
board.stopStream();
const data = board.getCurrentBoardData(10);
board.releaseSession()
const eegChannels = BoardShim.getEegChannels(boardId);
const oldData = data[eegChannels[0]];
console.info(oldData);
const newData = DataFilter.performDownsampling(oldData, 3, AggOperations.MEAN);
console.info(newData);
}
runExample ();
Typescript Transforms¶
import {
BoardIds,
BoardShim,
DataFilter,
WaveletExtensionTypes,
WaveletTypes,
WindowOperations
} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const boardId = BoardIds.SYNTHETIC_BOARD;
const board = new BoardShim (boardId, {});
board.prepareSession();
board.startStream();
await sleep (3000);
board.stopStream();
const data = board.getCurrentBoardData(64);
board.releaseSession()
const eegChannels = BoardShim.getEegChannels(boardId);
const oldData = data[eegChannels[0]];
console.info(oldData);
const fftData = DataFilter.performFft(oldData, WindowOperations.NO_WINDOW);
console.info(fftData);
const newData = DataFilter.performIfft(fftData);
console.info(newData);
const waveletData = DataFilter.performWaveletTransform(
newData, WaveletTypes.DB2, 2, WaveletExtensionTypes.SYMMETRIC);
const restoredData = DataFilter.performInverseWaveletTransform(
waveletData, newData.length, WaveletTypes.DB2, 2, WaveletExtensionTypes.SYMMETRIC);
console.info(restoredData);
}
runExample ();
Typescript Signal Filtering¶
import {BoardIds, BoardShim, DataFilter, FilterTypes} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const boardId = BoardIds.SYNTHETIC_BOARD;
const board = new BoardShim (boardId, {});
board.prepareSession();
board.startStream();
await sleep (3000);
board.stopStream();
const data = board.getBoardData();
board.releaseSession()
console.info('Data');
console.info(data);
const eegChannels = BoardShim.getEegChannels(boardId);
const samplingRate = BoardShim.getSamplingRate(boardId);
DataFilter.performBandPass(
data[eegChannels[0]], samplingRate, 3.0, 20.0, 2, FilterTypes.BUTTERWORTH_ZERO_PHASE, 0.0);
DataFilter.performBandStop(
data[eegChannels[0]], samplingRate, 48.0, 52.0, 2, FilterTypes.BUTTERWORTH_ZERO_PHASE, 0.0);
DataFilter.performLowPass(
data[eegChannels[0]], samplingRate, 48.0, 2, FilterTypes.BUTTERWORTH_ZERO_PHASE, 0.0);
DataFilter.performHighPass(
data[eegChannels[0]], samplingRate, 3.0, 2, FilterTypes.BUTTERWORTH_ZERO_PHASE, 0.0);
}
runExample ();
Typescript Denoising¶
import {BoardIds, BoardShim, DataFilter, WaveletTypes} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const boardId = BoardIds.SYNTHETIC_BOARD;
const board = new BoardShim (boardId, {});
board.prepareSession();
board.startStream();
await sleep (5000);
board.stopStream();
const data = board.getBoardData();
board.releaseSession()
const eegChannels = BoardShim.getEegChannels(boardId);
const oldData = data[eegChannels[0]];
console.info(oldData);
DataFilter.performWaveletDenoising(oldData, WaveletTypes.DB2, 2);
console.info(oldData);
}
runExample ();
Typescript Band Power¶
import {BoardIds, BoardShim, DataFilter, WindowOperations} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const boardId = BoardIds.SYNTHETIC_BOARD;
const board = new BoardShim (boardId, {});
board.prepareSession();
board.startStream();
await sleep (5000);
board.stopStream();
const data = board.getCurrentBoardData(128);
board.releaseSession()
const eegChannels = BoardShim.getEegChannels(boardId);
const samplingRate = BoardShim.getSamplingRate(boardId);
const oldData = data[eegChannels[1]];
const psd = DataFilter.getPsdWelch(oldData, 64, 0.5, samplingRate, WindowOperations.HAMMING);
const alpha = DataFilter.getBandPower(psd, 7.0, 13.0);
const beta = DataFilter.getBandPower(psd, 14.0, 30.0);
console.info(alpha / beta);
}
runExample ();
Typescript EEG Metrics¶
import {
BoardIds,
BoardShim,
BrainFlowClassifiers,
BrainFlowMetrics,
DataFilter,
MLModel
} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const boardId = BoardIds.SYNTHETIC_BOARD;
const board = new BoardShim (boardId, {});
board.prepareSession();
board.startStream();
await sleep (3000);
board.stopStream();
const data = board.getBoardData();
board.releaseSession()
console.info(data);
const eegChannels = BoardShim.getEegChannels(boardId);
const samplingRate = BoardShim.getSamplingRate(boardId);
const bands = DataFilter.getAvgBandPowers(data, eegChannels, samplingRate, true);
const model =
new MLModel (BrainFlowMetrics.RESTFULNESS, BrainFlowClassifiers.DEFAULT_CLASSIFIER, {});
model.prepare();
console.info(model.predict(bands[0]));
model.release();
}
runExample ();
Typescript ICA¶
import {BoardIds, BoardShim, DataFilter} from 'brainflow';
function sleep (ms: number)
{
return new Promise ((resolve) => { setTimeout (resolve, ms); });
}
async function runExample (): Promise<void>
{
const boardId = BoardIds.SYNTHETIC_BOARD;
const board = new BoardShim (boardId, {});
board.prepareSession();
board.startStream();
await sleep (10000);
board.stopStream();
const data = board.getCurrentBoardData(500);
board.releaseSession()
const eegChannels = BoardShim.getEegChannels(boardId);
const eegData = data[eegChannels[0]];
const eeg2D: number[][] = [];
while (eegData.length)
eeg2D.push(eegData.splice(0, 100));
const icaData = DataFilter.performIca(eeg2D, 2, [0, 1, 2, 3, 4]);
console.info(icaData[3]);
}
runExample ();