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
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.add_streamer("file://data.csv:w")
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 numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from brainflow.data_filter import DataFilter
def main():
# Two simultaneous mixtures: rows are channels and columns are samples.
time = np.arange(1024, dtype=np.float64) / 256.0
first = np.sin(2.0 * np.pi * 7.0 * time)
second = np.sin(2.0 * np.pi * 13.0 * time) ** 3
data = np.vstack((first + 0.3 * second, 0.2 * first + second))
# Component order and sign are arbitrary.
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 QtWidgets, 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 = QtWidgets.QApplication([])
self.win = pg.GraphicsLayoutWidget(title='BrainFlow Plot', size=(800, 600), show=True)
self._init_timeseries()
timer = QtCore.QTimer()
timer.timeout.connect(self.update)
timer.start(self.update_speed_ms)
QtWidgets.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++)
{
String arg = args[i];
if ((arg.equals ("--ip-address") || arg.equals ("--ip-address-aux") || arg.equals ("--ip-address-anc")
|| arg.equals ("--serial-port") || arg.equals ("--ip-port") || arg.equals ("--ip-port-aux")
|| arg.equals ("--ip-port-anc") || arg.equals ("--ip-protocol") || arg.equals ("--other-info")
|| arg.equals ("--board-id") || arg.equals ("--timeout") || arg.equals ("--serial-number")
|| arg.equals ("--file") || arg.equals ("--file-aux") || arg.equals ("--file-anc")
|| arg.equals ("--master-board")) && (i + 1 >= args.length))
{
throw new IllegalArgumentException ("Missing value for argument: " + arg);
}
if (arg.equals ("--ip-address"))
{
params.ip_address = args[i + 1];
}
if (arg.equals ("--ip-address-aux"))
{
params.ip_address_aux = args[i + 1];
}
if (arg.equals ("--ip-address-anc"))
{
params.ip_address_anc = args[i + 1];
}
if (arg.equals ("--serial-port"))
{
params.serial_port = args[i + 1];
}
if (arg.equals ("--ip-port"))
{
params.ip_port = Integer.parseInt (args[i + 1]);
}
if (arg.equals ("--ip-port-aux"))
{
params.ip_port_aux = Integer.parseInt (args[i + 1]);
}
if (arg.equals ("--ip-port-anc"))
{
params.ip_port_anc = Integer.parseInt (args[i + 1]);
}
if (arg.equals ("--ip-protocol"))
{
params.ip_protocol = Integer.parseInt (args[i + 1]);
}
if (arg.equals ("--other-info"))
{
params.other_info = args[i + 1];
}
if (arg.equals ("--board-id"))
{
board_id = Integer.parseInt (args[i + 1]);
}
if (arg.equals ("--timeout"))
{
params.timeout = Integer.parseInt (args[i + 1]);
}
if (arg.equals ("--serial-number"))
{
params.serial_number = args[i + 1];
}
if (arg.equals ("--file"))
{
params.file = args[i + 1];
}
if (arg.equals ("--file-aux"))
{
params.file_aux = args[i + 1];
}
if (arg.equals ("--file-anc"))
{
params.file_anc = args[i + 1];
}
if (arg.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++)
{
String arg = args[i];
boolean requires_value = arg.equals ("--ip-address") || arg.equals ("--serial-port")
|| arg.equals ("--ip-port") || arg.equals ("--ip-protocol")
|| arg.equals ("--other-info") || arg.equals ("--board-id")
|| arg.equals ("--timeout") || arg.equals ("--serial-number")
|| arg.equals ("--file");
if (requires_value && i + 1 >= args.length)
{
throw new IllegalArgumentException ("Missing value for argument: " + arg);
}
if (arg.equals ("--ip-address"))
{
params.ip_address = args[i + 1];
i++;
}
if (arg.equals ("--serial-port"))
{
params.serial_port = args[i + 1];
i++;
}
if (arg.equals ("--ip-port"))
{
params.ip_port = Integer.parseInt (args[i + 1]);
i++;
}
if (arg.equals ("--ip-protocol"))
{
params.ip_protocol = Integer.parseInt (args[i + 1]);
i++;
}
if (arg.equals ("--other-info"))
{
params.other_info = args[i + 1];
i++;
}
if (arg.equals ("--board-id"))
{
board_id = Integer.parseInt (args[i + 1]);
i++;
}
if (arg.equals ("--timeout"))
{
params.timeout = Integer.parseInt (args[i + 1]);
i++;
}
if (arg.equals ("--serial-number"))
{
params.serial_number = args[i + 1];
i++;
}
if (arg.equals ("--file"))
{
params.file = args[i + 1];
i++;
}
}
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++)
{
String arg = args[i];
if (arg.equals ("--ip-address") || arg.equals ("--serial-port") || arg.equals ("--ip-port")
|| arg.equals ("--ip-protocol") || arg.equals ("--other-info") || arg.equals ("--board-id")
|| arg.equals ("--timeout") || arg.equals ("--serial-number") || arg.equals ("--file"))
{
if (i + 1 >= args.length)
{
throw new IllegalArgumentException ("Missing value for argument: " + arg);
}
String value = args[++i];
if (arg.equals ("--ip-address"))
{
params.ip_address = value;
}
else if (arg.equals ("--serial-port"))
{
params.serial_port = value;
}
else if (arg.equals ("--ip-port"))
{
params.ip_port = Integer.parseInt (value);
}
else if (arg.equals ("--ip-protocol"))
{
params.ip_protocol = Integer.parseInt (value);
}
else if (arg.equals ("--other-info"))
{
params.other_info = value;
}
else if (arg.equals ("--board-id"))
{
board_id = Integer.parseInt (value);
}
else if (arg.equals ("--timeout"))
{
params.timeout = Integer.parseInt (value);
}
else if (arg.equals ("--serial-number"))
{
params.serial_number = value;
}
else if (arg.equals ("--file"))
{
params.file = value;
}
}
}
return board_id;
}
}
Java ICA
package brainflow.examples;
import java.util.List;
import brainflow.DataFilter;
public class ICA
{
public static void main (String[] args) throws Exception
{
// Two simultaneous mixtures: rows are channels and columns are samples.
int samples = 1024;
double[][] data = new double[2][samples];
for (int i = 0; i < samples; i++)
{
double t = i / 256.0;
double first = Math.sin (2.0 * Math.PI * 7.0 * t);
double second = Math.pow (Math.sin (2.0 * Math.PI * 13.0 * t), 3);
data[0][i] = first + 0.3 * second;
data[1][i] = 0.2 * first + second;
}
List<double[][]> ica = DataFilter.perform_ica (data, 2);
// Component order and sign are arbitrary.
System.out.println ("Recovered " + ica.get (3).length + " sources from " + samples + " samples");
}
}
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 brainflow;
namespace examples
{
class ICA
{
static void Main (string[] args)
{
// Two simultaneous mixtures: rows are channels and columns are samples.
const int samples = 1024;
double[,] data = new double[2, samples];
for (int i = 0; i < samples; i++)
{
double t = i / 256.0;
double first = Math.Sin (2.0 * Math.PI * 7.0 * t);
double second = Math.Pow (Math.Sin (2.0 * Math.PI * 13.0 * t), 3);
data[0, i] = first + 0.3 * second;
data[1, i] = 0.2 * first + second;
}
var ica = DataFilter.perform_ica (data, 2);
// Component order and sign are arbitrary.
Console.WriteLine ("Recovered " + ica.Item4.GetLength (0) + " sources from " + samples + " samples");
}
}
}
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 <cmath>
#include <iostream>
#include "data_filter.h"
int main ()
{
// Two simultaneous mixtures of non-Gaussian sources: rows are channels, columns are samples.
const int samples = 1024;
const double pi = std::acos (-1.0);
BrainFlowArray<double, 2> data (2, samples);
for (int i = 0; i < samples; i++)
{
double t = i / 256.0;
double first = std::sin (2.0 * pi * 7.0 * t);
double second = std::pow (std::sin (2.0 * pi * 13.0 * t), 3);
data.at (0, i) = first + 0.3 * second;
data.at (1, i) = 0.2 * first + second;
}
try
{
auto result = DataFilter::perform_ica (data, 2);
// Component order and sign are arbitrary.
std::cout << "Recovered " << std::get<3> (result).get_size (0) << " sources from "
<< samples << " samples" << std::endl;
}
catch (const BrainFlowException &err)
{
std::cerr << err.what () << std::endl;
return err.exit_code;
}
return 0;
}
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)
# Two simultaneous mixtures: rows are channels and columns are samples.
sample_times <- (0:1023) / 256
source1 <- sin(2 * pi * 7 * sample_times)
source2 <- sin(2 * pi * 13 * sample_times)^3
mixed_data <- rbind(source1 + 0.3 * source2, 0.2 * source1 + source2)
numpy_data <- np$array(mixed_data, dtype = np$float64, order = "C")
# Component order and sign are arbitrary.
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
% Two simultaneous mixtures: rows are channels and columns are samples.
time = (0:1023) / 256;
first = sin(2 * pi * 7 * time);
second = sin(2 * pi * 13 * time).^3;
data = [first + 0.3 * second; 0.2 * first + second];
[w, k, a, s] = DataFilter.perform_ica(data, 2);
% Component order and sign are arbitrary.
fprintf('Recovered %d sources from %d samples\n', size(s, 1), size(s, 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
# Two simultaneous mixtures: rows are channels and columns are samples.
sample_times = collect(0:1023) ./ 256.0
source1 = sin.(2.0 .* pi .* 7.0 .* sample_times)
source2 = sin.(2.0 .* pi .* 13.0 .* sample_times) .^ 3
data = permutedims(hcat(source1 .+ 0.3 .* source2, 0.2 .* source1 .+ source2))
w, k, a, sources = BrainFlow.perform_ica(data, 2)
# Component order and sign are arbitrary.
println("Recovered $(size(sources, 1)) sources from $(size(sources, 2)) samples")
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 brainflow::data_filter;
use ndarray::Array2;
use std::f64::consts::PI;
fn main() -> Result<(), Box<dyn std::error::Error>> {
// Two simultaneous mixtures: rows are channels and columns are samples.
let data = Array2::from_shape_fn((2, 1024), |(row, col)| {
let t = col as f64 / 256.0;
let first = (2.0 * PI * 7.0 * t).sin();
let second = (2.0 * PI * 13.0 * t).sin().powi(3);
if row == 0 { first + 0.3 * second } else { 0.2 * first + second }
});
let (_, _, _, sources) = data_filter::perform_ica(data, 2)?;
// Component order and sign are arbitrary.
println!("Recovered 2 sources from {} samples", sources.len() / 2);
Ok(())
}
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();
// Include enough data for Welch estimation after trimming filter transients.
await sleep (8000);
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 {DataFilter} from 'brainflow';
// Two simultaneous mixtures: rows are channels and columns are samples.
const samples = 1024;
const data: number[][] = [[], []];
for (let i = 0; i < samples; i++)
{
const t = i / 256;
const first = Math.sin(2 * Math.PI * 7 * t);
const second = Math.pow(Math.sin(2 * Math.PI * 13 * t), 3);
data[0].push(first + 0.3 * second);
data[1].push(0.2 * first + second);
}
const ica = DataFilter.performIca(data, 2, [0, 1]);
// Component order and sign are arbitrary.
console.info(`Recovered ${ica[3].length} sources from ${samples} samples`);
Swift
The Swift examples below are also Swift Package Manager executable products. After building native BrainFlow libraries, run them from swift_package with BRAINFLOW_LIB_DIR=../installed/lib swift run <example-name>. For example, swift run swift-brainflow-get-data.
Swift Get Data from a Board
import BrainFlow
import Foundation
@main
enum BrainFlowGetDataExample {
static func main() throws {
let board = try BoardShim(board_id: BoardIds.SYNTHETIC_BOARD)
try board.prepare_session()
try board.start_stream(buffer_size: 45000)
Thread.sleep(forTimeInterval: 5.0)
try board.stop_stream()
let data = try board.get_board_data()
try board.release_session()
print("Rows: \(data.count)")
print("Samples: \(data.first?.count ?? 0)")
}
}
Swift Markers
import BrainFlow
import Foundation
@main
enum MarkersExample {
static func main() throws {
let board = try BoardShim(board_id: BoardIds.SYNTHETIC_BOARD)
try board.prepare_session()
try board.start_stream(buffer_size: 45000)
try board.insert_marker(1.0)
Thread.sleep(forTimeInterval: 1.0)
try board.stop_stream()
let data = try board.get_board_data()
try board.release_session()
let markerChannel = try BoardShim.get_marker_channel(board_id: BoardIds.SYNTHETIC_BOARD.rawValue)
print("Marker channel: \(markerChannel)")
print("Samples: \(data[markerChannel].count)")
}
}
Swift Read Write File
import BrainFlow
import BrainFlowExampleSupport
import Foundation
@main
enum ReadWriteFileExample {
static func main() throws {
let sample = try SyntheticBoardDataReader.read(seconds: 2.0)
let fileName = NSTemporaryDirectory() + "/brainflow_swift.csv"
try DataFilter.write_file(data: sample.data, file_name: fileName, file_mode: "w")
let restored = try DataFilter.read_file(fileName)
print("Original: \(sample.data.count)x\(sample.data.first?.count ?? 0)")
print("Restored: \(restored.count)x\(restored.first?.count ?? 0)")
}
}
Swift Downsample Data
import BrainFlow
import BrainFlowExampleSupport
@main
enum DownsamplingExample {
static func main() throws {
let sample = try SyntheticBoardDataReader.read(maxSamples: 256)
let data = try sample.firstEEGChannel()
let downsampled = try DataFilter.perform_downsampling(data: data, period: 4, operation: AggOperations.MEAN)
print(downsampled)
}
}
Swift Transforms
import BrainFlow
import BrainFlowExampleSupport
@main
enum TransformsExample {
static func main() throws {
let sample = try SyntheticBoardDataReader.read(maxSamples: 256)
let data = try sample.firstEEGChannel()
let fft = try DataFilter.perform_fft(data: data, start_pos: 0, end_pos: data.count, window: WindowOperations.HANNING)
let restored = try DataFilter.perform_ifft(data: fft)
print("FFT bins: \(fft.count)")
print("Restored samples: \(restored.count)")
}
}
Swift Signal Filtering
import BrainFlow
import BrainFlowExampleSupport
@main
enum SignalFilteringExample {
static func main() throws {
let sample = try SyntheticBoardDataReader.read(maxSamples: 256)
var data = try sample.firstEEGChannel()
try DataFilter.perform_lowpass(data: &data, sampling_rate: sample.samplingRate, cutoff: 30.0, order: 4, filter_type: FilterTypes.BUTTERWORTH, ripple: 0.0)
try DataFilter.perform_highpass(data: &data, sampling_rate: sample.samplingRate, cutoff: 1.0, order: 4, filter_type: FilterTypes.BUTTERWORTH, ripple: 0.0)
print(data.prefix(10))
}
}
Swift Denoising
import BrainFlow
import BrainFlowExampleSupport
@main
enum DenoisingExample {
static func main() throws {
let sample = try SyntheticBoardDataReader.read(maxSamples: 256)
var data = try sample.firstEEGChannel()
try DataFilter.perform_wavelet_denoising(
data: &data,
wavelet: WaveletTypes.DB5,
decomposition_level: 3,
wavelet_denoising: WaveletDenoisingTypes.SURESHRINK,
threshold: ThresholdTypes.HARD,
extension_type: WaveletExtensionTypes.SYMMETRIC,
noise_level: NoiseEstimationLevelTypes.FIRST_LEVEL
)
print(data.prefix(10))
}
}
Swift Band Power
import BrainFlow
import BrainFlowExampleSupport
@main
enum BandPowerExample {
static func main() throws {
let sample = try SyntheticBoardDataReader.read(maxSamples: 256)
let data = try sample.firstEEGChannel()
let psd = try DataFilter.get_psd(
data: data,
start_pos: 0,
end_pos: data.count,
sampling_rate: sample.samplingRate,
window: WindowOperations.HANNING.rawValue
)
let alpha = try DataFilter.get_band_power(psd: psd, freq_start: 8.0, freq_end: 13.0)
print("Alpha power: \(alpha)")
}
}
Swift EEG Metrics
import BrainFlow
import BrainFlowExampleSupport
@main
enum EEGMetricsExample {
static func main() throws {
let sample = try SyntheticBoardDataReader.read()
let bandPowers = try DataFilter.get_avg_band_powers(
data: sample.data,
channels: sample.eegChannels,
sampling_rate: sample.samplingRate,
apply_filter: true
)
let params = BrainFlowModelParams(metric: BrainFlowMetrics.MINDFULNESS, classifier: BrainFlowClassifiers.DEFAULT_CLASSIFIER)
let model = try MLModel(params: params)
try model.prepare()
let prediction = try model.predict(input_data: bandPowers.average)
try model.release()
print(prediction)
}
}
Swift ICA
import Foundation
import BrainFlow
@main
enum ICAExample {
static func main() throws {
// Two simultaneous mixtures: rows are channels and columns are samples.
let samples = 1024
var data = [[Double]](repeating: [Double](repeating: 0, count: samples), count: 2)
for i in 0..<samples {
let t = Double(i) / 256.0
let first = sin(2.0 * Double.pi * 7.0 * t)
let second = pow(sin(2.0 * Double.pi * 13.0 * t), 3.0)
data[0][i] = first + 0.3 * second
data[1][i] = 0.2 * first + second
}
let ica = try DataFilter.perform_ica(data: data, num_components: 2)
// Component order and sign are arbitrary.
print("Recovered \(ica.s.count) sources from \(samples) samples")
}
}