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
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
import numpy as np
import brainflow
from brainflow.board_shim import BoardShim, BrainFlowInputParams
from brainflow.data_filter import DataFilter, FilterTypes, AggOperations
def main ():
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 = '')
parser.add_argument ('--log', action = 'store_true')
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
if (args.log):
BoardShim.enable_dev_board_logger ()
else:
BoardShim.disable_board_logger ()
board = BoardShim (args.board_id, params)
board.prepare_session ()
# board.start_stream () # use this for default options
board.start_stream (45000, args.streamer_params)
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 Read Write File¶
import argparse
import time
import numpy as np
import pandas as pd
import brainflow
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, 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_current_board_data (20) # get 20 latest data points dont remove them from internal buffer
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
import numpy as np
import brainflow
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, 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_current_board_data (20) # get 20 latest data points dont remove them from internal buffer
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 argparse
import time
import brainflow
import numpy as np
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, AggOperations, WindowFunctions
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 (DataFilter.get_nearest_power_of_two (sampling_rate))
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], '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], '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], WindowFunctions.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 argparse
import time
import brainflow
import numpy as np
import pandas as pd
import matplotlib
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
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), 15.0, 6.0, 4, FilterTypes.BESSEL.value, 0)
elif count == 1:
DataFilter.perform_bandstop (data[channel], BoardShim.get_sampling_rate (board_id), 30.0, 1.0, 3, FilterTypes.BUTTERWORTH.value, 0)
elif count == 2:
DataFilter.perform_lowpass (data[channel], BoardShim.get_sampling_rate (board_id), 20.0, 5, FilterTypes.CHEBYSHEV_TYPE_1.value, 1)
elif count == 3:
DataFilter.perform_highpass (data[channel], BoardShim.get_sampling_rate (board_id), 3.0, 4, FilterTypes.BUTTERWORTH.value, 0)
elif count == 4:
DataFilter.perform_rolling_filter (data[channel], 3, AggOperations.MEAN.value)
elif count == 5:
DataFilter.perform_rolling_filter (data[channel], 3, AggOperations.MEDIAN.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 argparse
import time
import brainflow
import numpy as np
import pandas as pd
import matplotlib
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
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 (20)
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')
# 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 functions and decomposition levels
elif count == 2:
DataFilter.perform_wavelet_denoising (data[channel], 'db6', 3)
elif count == 3:
DataFilter.perform_wavelet_denoising (data[channel], 'bior3.9', 3)
elif count == 4:
DataFilter.perform_wavelet_denoising (data[channel], 'sym7', 3)
elif count == 5:
# with synthetic board this one looks like the best option, but it depends on many circumstances
DataFilter.perform_wavelet_denoising (data[channel], 'coif3', 3)
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 numpy as np
import matplotlib
matplotlib.use ('Agg')
import matplotlib.pyplot as plt
import pandas as pd
import brainflow
from brainflow.board_shim import BoardShim, BrainFlowInputParams, BoardIds
import mne
from mne.channels import read_layout
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 argparse
import time
import brainflow
import numpy as np
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds
from brainflow.data_filter import DataFilter, FilterTypes, AggOperations, WindowFunctions, DetrendOperations
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)
nfft = DataFilter.get_nearest_power_of_two (sampling_rate)
data = board.get_board_data ()
board.stop_stream ()
board.release_session ()
eeg_channels = BoardShim.get_eeg_channels (board_id)
# 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, WindowFunctions.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)
# fail test if ratio is not smth we expect
if (band_power_alpha / band_power_beta < 100):
raise ValueError ('Wrong Ratio')
if __name__ == "__main__":
main ()
Python EEG Metrics¶
import argparse
import time
import brainflow
import numpy as np
from brainflow.board_shim import BoardShim, BrainFlowInputParams, LogLevels, BoardIds,BrainFlowError
from brainflow.data_filter import DataFilter, FilterTypes, AggOperations, WindowFunctions, DetrendOperations
from brainflow.ml_model import MLModel, BrainFlowMetrics, BrainFlowClassifiers, BrainFlowModelParams
from brainflow.exit_codes import *
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 = np.concatenate ((bands[0], bands[1]))
print(feature_vector)
# calc concentration
concentration_params = BrainFlowModelParams (BrainFlowMetrics.CONCENTRATION.value, BrainFlowClassifiers.KNN.value)
concentration = MLModel (concentration_params)
concentration.prepare ()
print ('Concentration: %f' % concentration.predict (feature_vector))
concentration.release ()
# calc relaxation
relaxation_params = BrainFlowModelParams (BrainFlowMetrics.RELAXATION.value, BrainFlowClassifiers.REGRESSION.value)
relaxation = MLModel (relaxation_params)
relaxation.prepare ()
print ('Relaxation: %f' % relaxation.predict (feature_vector))
relaxation.release ()
if __name__ == "__main__":
main ()
Java¶
Java Get Data from a Board¶
package brainflow.examples;
import java.util.Arrays;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.LogLevels;
public class BrainFlowGetData
{
public static void main (String[] args) throws Exception
{
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = parse_args (args, params);
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
// board_shim.start_stream (); // use this for default options
board_shim.start_stream (450000, "file://file_stream.csv:w");
BoardShim.log_message (LogLevels.LEVEL_INFO.get_code (), "Start sleeping in the main thread");
Thread.sleep (5000);
board_shim.stop_stream ();
System.out.println (board_shim.get_board_data_count ());
double[][] data = board_shim.get_current_board_data (30); // doesnt flush it from ring buffer
// double[][] data = board_shim.get_board_data (); // get all data and flush
// from ring buffer
for (int i = 0; i < data.length; i++)
{
System.out.println (Arrays.toString (data[i]));
}
board_shim.release_session ();
}
private static int parse_args (String[] args, BrainFlowInputParams params)
{
int board_id = -1;
for (int i = 0; i < args.length; i++)
{
if (args[i].equals ("--ip-address"))
{
params.ip_address = args[i + 1];
}
if (args[i].equals ("--serial-port"))
{
params.serial_port = args[i + 1];
}
if (args[i].equals ("--ip-port"))
{
params.ip_port = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--ip-protocol"))
{
params.ip_protocol = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--other-info"))
{
params.other_info = args[i + 1];
}
if (args[i].equals ("--board-id"))
{
board_id = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--timeout"))
{
params.timeout = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--serial-number"))
{
params.serial_number = args[i + 1];
}
if (args[i].equals ("--file"))
{
params.file = args[i + 1];
}
}
return board_id;
}
}
Java Read Write File¶
package brainflow.examples;
import java.util.Arrays;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
import brainflow.LogLevels;
public class Serialization
{
public static void main (String[] args) throws Exception
{
// use Synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = BoardIds.SYNTHETIC_BOARD.get_code ();
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
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 ());
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 ();
int board_id = BoardIds.SYNTHETIC_BOARD.get_code ();
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
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);
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.get_code ());
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.WindowFunctions;
public class Transforms
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = BoardIds.SYNTHETIC_BOARD.get_code ();
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
BoardShim.log_message (LogLevels.LEVEL_INFO.get_code (), "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]], "db4", 3);
// 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, "db4", 3);
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,
WindowFunctions.NO_WINDOW.get_code ());
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;
public class SignalFiltering
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = BoardIds.SYNTHETIC_BOARD.get_code ();
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
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 ());
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), 20.0, 4,
FilterTypes.BESSEL.get_code (), 0.0);
break;
case 1:
DataFilter.perform_highpass (data[eeg_channels[i]], BoardShim.get_sampling_rate (board_id), 5.0, 4,
FilterTypes.BUTTERWORTH.get_code (), 0.0);
break;
case 2:
DataFilter.perform_bandpass (data[eeg_channels[i]], BoardShim.get_sampling_rate (board_id), 15.0,
5.0, 4, FilterTypes.CHEBYSHEV_TYPE_1.get_code (), 1.0);
break;
case 3:
DataFilter.perform_bandstop (data[eeg_channels[i]], BoardShim.get_sampling_rate (board_id), 50.0,
1.0, 4, FilterTypes.CHEBYSHEV_TYPE_1.get_code (), 1.0);
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 brainflow.AggOperations;
import brainflow.BoardIds;
import brainflow.BoardShim;
import brainflow.BrainFlowInputParams;
import brainflow.DataFilter;
import brainflow.LogLevels;
import java.util.Arrays;
public class Denoising
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = BoardIds.SYNTHETIC_BOARD.get_code ();
BoardShim board_shim = new BoardShim (board_id, params);
board_shim.prepare_session ();
board_shim.start_stream (3600);
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 ());
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++)
{
// 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.get_code ());
break;
case 1:
DataFilter.perform_rolling_filter (data[eeg_channels[i]], 3, AggOperations.MEDIAN.get_code ());
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]], "db4", 3);
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.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.DetrendOperations;
import brainflow.LogLevels;
import brainflow.WindowFunctions;
public class BandPower
{
public static void main (String[] args) throws Exception
{
// use synthetic board for demo
BoardShim.enable_board_logger ();
BrainFlowInputParams params = new BrainFlowInputParams ();
int board_id = BoardIds.SYNTHETIC_BOARD.get_code ();
BoardShim board_shim = new BoardShim (board_id, params);
int sampling_rate = BoardShim.get_sampling_rate (board_id);
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.get_code (), "Start sleeping in the main thread");
Thread.sleep (10000);
board_shim.stop_stream ();
double[][] data = board_shim.get_board_data ();
board_shim.release_session ();
int[] eeg_channels = BoardShim.get_eeg_channels (board_id);
// seconds channel of synthetic board has big 'alpha' use it for test
int eeg_channel = eeg_channels[1];
// optional: detrend before psd
DataFilter.detrend (data[eeg_channel], DetrendOperations.LINEAR.get_code ());
Pair<double[], double[]> psd = DataFilter.get_psd_welch (data[eeg_channel], nfft, nfft / 2, sampling_rate,
WindowFunctions.HANNING.get_code ());
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.ArrayUtils;
import org.apache.commons.lang3.tuple.Pair;
import brainflow.BoardIds;
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.get_code (), "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 = ArrayUtils.addAll (bands.getLeft (), bands.getRight ());
BrainFlowModelParams model_params = new BrainFlowModelParams (BrainFlowMetrics.CONCENTRATION.get_code (),
BrainFlowClassifiers.REGRESSION.get_code ());
MLModel concentration = new MLModel (model_params);
concentration.prepare ();
System.out.print ("Concentration: " + concentration.predict (feature_vector));
concentration.release ();
}
private static int parse_args (String[] args, BrainFlowInputParams params)
{
int board_id = -1;
for (int i = 0; i < args.length; i++)
{
if (args[i].equals ("--ip-address"))
{
params.ip_address = args[i + 1];
}
if (args[i].equals ("--serial-port"))
{
params.serial_port = args[i + 1];
}
if (args[i].equals ("--ip-port"))
{
params.ip_port = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--ip-protocol"))
{
params.ip_protocol = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--other-info"))
{
params.other_info = args[i + 1];
}
if (args[i].equals ("--board-id"))
{
board_id = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--timeout"))
{
params.timeout = Integer.parseInt (args[i + 1]);
}
if (args[i].equals ("--serial-number"))
{
params.serial_number = args[i + 1];
}
if (args[i].equals ("--file"))
{
params.file = args[i + 1];
}
}
return board_id;
}
}
C#¶
C# Read Data from a Board¶
using System;
using brainflow;
using Accord.Math;
namespace test
{
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 (); // use this for default options
board_shim.start_stream (450000, "file://file_stream.csv:w");
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# Read Write File¶
using System;
using brainflow;
using Accord.Math;
namespace test
{
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 Accord.Math;
namespace test
{
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_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++)
{
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 Accord.Math;
namespace test
{
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]), "db4", 3);
// 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, "db4", 3);
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)WindowFunctions.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 Accord.Math;
namespace test
{
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 demo apply different filters to different channels
double[] filtered;
for (int i = 0; i < eeg_channels.Length; i++)
{
Console.WriteLine ("Before processing:");
Console.WriteLine ("[{0}]", string.Join (", ", unprocessed_data.GetRow (eeg_channels[i])));
switch (i)
{
case 0:
filtered = DataFilter.perform_lowpass (unprocessed_data.GetRow(eeg_channels[i]), BoardShim.get_sampling_rate (board_id), 20.0, 4, (int)FilterTypes.BESSEL, 0.0);
Console.WriteLine ("Filtered channel " + eeg_channels[i]);
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
break;
case 1:
filtered = DataFilter.perform_highpass (unprocessed_data.GetRow (eeg_channels[i]), BoardShim.get_sampling_rate (board_id), 2.0, 4, (int)FilterTypes.BUTTERWORTH, 0.0);
Console.WriteLine ("Filtered channel " + eeg_channels[i]);
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
break;
case 2:
filtered = DataFilter.perform_bandpass (unprocessed_data.GetRow (eeg_channels[i]), BoardShim.get_sampling_rate (board_id), 15.0, 5.0, 2, (int)FilterTypes.BUTTERWORTH, 0.0);
Console.WriteLine ("Filtered channel " + eeg_channels[i]);
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
break;
case 3:
filtered = DataFilter.perform_bandstop (unprocessed_data.GetRow (eeg_channels[i]), BoardShim.get_sampling_rate (board_id), 50.0, 1.0, 6, (int)FilterTypes.CHEBYSHEV_TYPE_1, 1.0);
Console.WriteLine ("Filtered channel " + eeg_channels[i]);
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
break;
}
}
}
}
}
C# Denoising¶
using System;
using brainflow;
using Accord.Math;
namespace test
{
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]), "db4", 3);
Console.WriteLine ("Filtered channel " + eeg_channels[i]);
Console.WriteLine ("[{0}]", string.Join (", ", filtered));
break;
}
}
}
}
}
C# Band Power¶
using System;
using System.Numerics;
using brainflow;
using Accord.Math;
namespace test
{
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;
int sampling_rate = BoardShim.get_sampling_rate (board_id);
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 = BoardShim.get_eeg_channels (board_id);
// 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)WindowFunctions.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 System.Numerics;
using brainflow;
using Accord.Math;
namespace test
{
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 nfft = DataFilter.get_nearest_power_of_two (sampling_rate);
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.Concatenate (bands.Item2);
BrainFlowModelParams model_params = new BrainFlowModelParams ((int)BrainFlowMetrics.CONCENTRATION, (int)BrainFlowClassifiers.REGRESSION);
MLModel concentration = new MLModel (model_params);
concentration.prepare ();
Console.WriteLine ("Concentration: " + concentration.predict (feature_vector));
concentration.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++¶
To compile examples below for Linux or MacOS run:
cd tests/cpp/get_data_demo
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_linux ..
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}
)
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;
void print_head (double **data_buf, int num_channels, int num_data_points);
bool parse_args (int argc, char *argv[], struct BrainFlowInputParams *params, int *board_id);
int main (int argc, char *argv[])
{
struct BrainFlowInputParams params;
int board_id = 0;
if (!parse_args (argc, argv, ¶ms, &board_id))
{
return -1;
}
BoardShim::enable_dev_board_logger ();
BoardShim *board = new BoardShim (board_id, params);
double **data = NULL;
int res = 0;
int num_rows = 0;
try
{
board->prepare_session ();
board->start_stream ();
// board->start_stream (45000, (char *)"file://file_stream_test.csv:a"); // store data in a
// file directly during streaming
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Start sleeping in the main thread");
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
int data_count = 0;
data = board->get_board_data (&data_count);
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "read %d packages", data_count);
board->release_session ();
// for STREAMING_BOARD and PLAYBACK_FILE_BOARD you have to query information using board id
// for master board because for STREAMING_BOARD data format is determined by master board!
if ((board_id == (int)BoardIds::STREAMING_BOARD) ||
(board_id == (int)BoardIds::PLAYBACK_FILE_BOARD))
{
board_id = std::stoi (params.other_info);
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Use Board Id %d", board_id);
}
num_rows = BoardShim::get_num_rows (board_id);
std::cout << std::endl << "Data from the board" << std::endl << std::endl;
print_head (data, num_rows, data_count);
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
if (board->is_prepared ())
{
board->release_session ();
}
}
if (data != NULL)
{
for (int i = 0; i < num_rows; i++)
{
delete[] data[i];
}
}
delete[] data;
delete board;
return res;
}
void print_head (double **data_buf, int num_channels, int num_data_points)
{
std::cout << "Total Channels for this board: " << num_channels << std::endl;
int num_points = (num_data_points < 5) ? num_data_points : 5;
for (int i = 0; i < num_channels; i++)
{
std::cout << "Channel " << i << ": ";
for (int j = 0; j < num_points; j++)
{
std::cout << data_buf[i][j] << ",";
}
std::cout << std::endl;
}
}
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++ Read Write File¶
#include <iostream>
#include <stdlib.h>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
void print_head (double **data_buf, int num_channels, int num_data_points);
int main (int argc, char *argv[])
{
struct BrainFlowInputParams params;
// use synthetic board for demo
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
BoardShim::enable_dev_board_logger ();
BoardShim *board = new BoardShim (board_id, params);
double **data = NULL;
int res = 0;
int num_rows = 0;
try
{
board->prepare_session ();
board->start_stream ();
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Start sleeping in the main thread");
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
int data_count = 0;
data = board->get_board_data (&data_count);
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "read %d packages", data_count);
board->release_session ();
num_rows = BoardShim::get_num_rows (board_id);
std::cout << std::endl << "Data from the board" << std::endl << std::endl;
print_head (data, num_rows, data_count);
// demo for serialization
DataFilter::write_file (
data, num_rows, data_count, "test.csv", "w"); // use "a" for append mode
int restored_num_rows = 0;
int restored_num_cols = 0;
double **restored_data =
DataFilter::read_file (&restored_num_rows, &restored_num_cols, "test.csv");
std::cout << std::endl
<< "Data from the file, num packages is " << restored_num_cols << std::endl
<< std::endl;
print_head (restored_data, restored_num_rows, restored_num_cols);
for (int i = 0; i < restored_num_rows; i++)
{
delete[] restored_data[i];
}
delete[] restored_data;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
}
if (data != NULL)
{
for (int i = 0; i < num_rows; i++)
{
delete[] data[i];
}
}
delete[] data;
delete board;
return res;
}
void print_head (double **data_buf, int num_channels, int num_data_points)
{
std::cout << "Total Channels for this board: " << num_channels << std::endl;
int num_points = (num_data_points < 5) ? num_data_points : 5;
for (int i = 0; i < num_channels; i++)
{
std::cout << "Channel " << i << ": ";
for (int j = 0; j < num_points; j++)
{
std::cout << data_buf[i][j] << ",";
}
std::cout << std::endl;
}
}
C++ Downsample Data¶
#include <iostream>
#include <stdlib.h>
#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[])
{
struct BrainFlowInputParams params;
// use synthetic board for demo
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
BoardShim::enable_dev_board_logger ();
BoardShim *board = new BoardShim (board_id, params);
double **data = NULL;
int *eeg_channels = NULL;
int num_rows = 0;
int res = 0;
try
{
board->prepare_session ();
board->start_stream ();
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Start sleeping in the main thread");
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
int data_count = 0;
data = board->get_board_data (&data_count);
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "read %d packages", data_count);
board->release_session ();
num_rows = BoardShim::get_num_rows (board_id);
// downsample only eeg channels and print them
int eeg_num_channels = 0;
eeg_channels = BoardShim::get_eeg_channels (board_id, &eeg_num_channels);
double *downsampled_data = NULL;
int filtered_size = 0;
for (int i = 0; i < eeg_num_channels; i++)
{
std::cout << "Data from :" << eeg_channels[i] << " before downsampling " << std::endl;
print_one_row (data[eeg_channels[i]], data_count);
// just for demo apply different downsampling algorithms to different channels
// downsampling here doesnt apply lowpass filter for you, it just aggregates data points
switch (i)
{
case 0:
downsampled_data = DataFilter::perform_downsampling (data[eeg_channels[i]],
data_count, 2, (int)AggOperations::MEAN, &filtered_size);
break;
case 1:
downsampled_data = DataFilter::perform_downsampling (data[eeg_channels[i]],
data_count, 3, (int)AggOperations::MEDIAN, &filtered_size);
break;
default:
downsampled_data = DataFilter::perform_downsampling (data[eeg_channels[i]],
data_count, 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 (data != NULL)
{
for (int i = 0; i < num_rows; i++)
{
delete[] data[i];
}
}
delete[] data;
delete[] eeg_channels;
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>
#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[])
{
struct BrainFlowInputParams params;
// use synthetic board for demo
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
BoardShim::enable_dev_board_logger ();
BoardShim *board = new BoardShim (board_id, params);
double **data = NULL;
int *eeg_channels = NULL;
int num_rows = 0;
int res = 0;
try
{
board->prepare_session ();
board->start_stream ();
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Start sleeping in the main thread");
#ifdef _WIN32
Sleep (10000);
#else
sleep (10);
#endif
board->stop_stream ();
int data_count = 0;
data = board->get_current_board_data (128, &data_count);
if (data_count != 128)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR,
"read %d packages, for this test we want exactly 128 packages", data_count);
return (int)BrainFlowExitCodes::GENERAL_ERROR;
}
board->release_session ();
num_rows = BoardShim::get_num_rows (board_id);
int eeg_num_channels = 0;
eeg_channels = BoardShim::get_eeg_channels (board_id, &eeg_num_channels);
for (int i = 0; i < eeg_num_channels; 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[eeg_channels[i]], data_count, "db4", 4);
// 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, "db4", 4);
std::cout << "Original data:" << std::endl;
print_one_row (data[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!
std::complex<double> *fft_data = DataFilter::perform_fft (
data[eeg_channels[i]], data_count, (int)WindowFunctions::NO_WINDOW);
// len of fft_data array is N / 2 + 1
std::cout << "FFT coeffs:" << std::endl;
for (int i = 0; i < data_count / 2 + 1; i++)
{
std::cout << fft_data[i] << " ";
}
std::cout << std::endl;
double *restored_from_fft_data = DataFilter::perform_ifft (fft_data, data_count);
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 (data != NULL)
{
for (int i = 0; i < num_rows; i++)
{
delete[] data[i];
}
}
delete[] data;
delete[] eeg_channels;
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>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
void print_head (double **data_buf, int num_channels, int num_data_points);
int main (int argc, char *argv[])
{
struct BrainFlowInputParams params;
// use synthetic board for demo
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
BoardShim::enable_dev_board_logger ();
DataFilter::enable_dev_data_logger ();
BoardShim *board = new BoardShim (board_id, params);
double **data = NULL;
int *eeg_channels = NULL;
int num_rows = 0;
int res = 0;
try
{
board->prepare_session ();
board->start_stream ();
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Start sleeping in the main thread");
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
int data_count = 0;
data = board->get_board_data (&data_count);
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "read %d packages", data_count);
board->release_session ();
num_rows = BoardShim::get_num_rows (board_id);
std::cout << std::endl << "Data from the board" << std::endl << std::endl;
print_head (data, num_rows, data_count);
int eeg_num_channels = 0;
eeg_channels = BoardShim::get_eeg_channels (board_id, &eeg_num_channels);
int filtered_size = 0;
double *downsampled_data = NULL;
for (int i = 0; i < eeg_num_channels; 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[eeg_channels[i]], data_count,
BoardShim::get_sampling_rate (board_id), 30.0, 3,
(int)FilterTypes::BUTTERWORTH, 0);
break;
case 1:
DataFilter::perform_highpass (data[eeg_channels[i]], data_count,
BoardShim::get_sampling_rate (board_id), 5.0, 5,
(int)FilterTypes::CHEBYSHEV_TYPE_1, 1);
break;
case 2:
DataFilter::perform_bandpass (data[eeg_channels[i]], data_count,
BoardShim::get_sampling_rate (board_id), 15.0, 5.0, 3,
(int)FilterTypes::BESSEL, 0);
break;
default:
DataFilter::perform_bandstop (data[eeg_channels[i]], data_count,
BoardShim::get_sampling_rate (board_id), 30.0, 1.0, 3,
(int)FilterTypes::BUTTERWORTH, 0);
break;
}
}
std::cout << std::endl << "Data after processing" << std::endl << std::endl;
print_head (data, num_rows, data_count);
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
}
if (data != NULL)
{
for (int i = 0; i < num_rows; i++)
{
delete[] data[i];
}
}
delete[] data;
delete[] eeg_channels;
delete board;
return res;
}
void print_head (double **data_buf, int num_channels, int num_data_points)
{
std::cout << "Total Channels for this board: " << num_channels << std::endl;
int num_points = (num_data_points < 5) ? num_data_points : 5;
for (int i = 0; i < num_channels; i++)
{
std::cout << "Channel " << i << ": ";
for (int j = 0; j < num_points; j++)
{
std::cout << data_buf[i][j] << ",";
}
std::cout << std::endl;
}
}
C++ Denoising¶
#include <iostream>
#include <stdlib.h>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#include "board_shim.h"
#include "data_filter.h"
using namespace std;
void print_head (double **data_buf, int num_channels, int num_data_points);
int main (int argc, char *argv[])
{
struct BrainFlowInputParams params;
// use synthetic board for demo
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
BoardShim::enable_dev_board_logger ();
BoardShim *board = new BoardShim (board_id, params);
double **data = NULL;
int *eeg_channels = NULL;
int num_rows = 0;
int res = 0;
try
{
board->prepare_session ();
board->start_stream ();
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Start sleeping in the main thread");
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
board->stop_stream ();
int data_count = 0;
data = board->get_board_data (&data_count);
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "read %d packages", data_count);
board->release_session ();
num_rows = BoardShim::get_num_rows (board_id);
std::cout << std::endl << "Data from the board" << std::endl << std::endl;
print_head (data, num_rows, data_count);
int eeg_num_channels = 0;
eeg_channels = BoardShim::get_eeg_channels (board_id, &eeg_num_channels);
for (int i = 0; i < eeg_num_channels; i++)
{
switch (i)
{
// for demo apply different methods to different channels, in production you should
// choose one
// first of all you can try simple moving average or moving median to remove noise
case 0:
DataFilter::perform_rolling_filter (
data[eeg_channels[i]], data_count, 3, (int)AggOperations::MEDIAN);
break;
case 1:
DataFilter::perform_rolling_filter (
data[eeg_channels[i]], data_count, 3, (int)AggOperations::MEAN);
break;
case 2:
DataFilter::perform_rolling_filter (
data[eeg_channels[i]], data_count, 5, (int)AggOperations::MEDIAN);
break;
case 3:
DataFilter::perform_rolling_filter (
data[eeg_channels[i]], data_count, 5, (int)AggOperations::MEAN);
break;
// 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
case 4:
DataFilter::perform_wavelet_denoising (
data[eeg_channels[i]], data_count, "db4", 3);
break;
case 5:
DataFilter::perform_wavelet_denoising (
data[eeg_channels[i]], data_count, "coif3", 3);
break;
}
}
std::cout << std::endl << "Data after denoising" << std::endl << std::endl;
print_head (data, num_rows, data_count);
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
}
if (data != NULL)
{
for (int i = 0; i < num_rows; i++)
{
delete[] data[i];
}
}
delete[] data;
delete[] eeg_channels;
delete board;
return res;
}
void print_head (double **data_buf, int num_channels, int num_data_points)
{
std::cout << "Total Channels for this board: " << num_channels << std::endl;
int num_points = (num_data_points < 5) ? num_data_points : 5;
for (int i = 0; i < num_channels; i++)
{
std::cout << "Channel " << i << ": ";
for (int j = 0; j < num_points; j++)
{
std::cout << data_buf[i][j] << ",";
}
std::cout << std::endl;
}
}
C++ Band Power¶
#include <iostream>
#include <stdlib.h>
#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[])
{
struct BrainFlowInputParams params;
// use synthetic board for demo
int board_id = (int)BoardIds::SYNTHETIC_BOARD;
BoardShim::enable_dev_board_logger ();
BoardShim *board = new BoardShim (board_id, params);
double **data = NULL;
int *eeg_channels = NULL;
int num_rows = 0;
int res = 0;
int sampling_rate = BoardShim::get_sampling_rate (board_id);
try
{
board->prepare_session ();
board->start_stream ();
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Start sleeping in the main thread");
#ifdef _WIN32
Sleep (10000);
#else
sleep (10);
#endif
board->stop_stream ();
int data_count = 0;
int fft_len = DataFilter::get_nearest_power_of_two (sampling_rate);
data = board->get_board_data (&data_count);
board->release_session ();
num_rows = BoardShim::get_num_rows (board_id);
int eeg_num_channels = 0;
eeg_channels = BoardShim::get_eeg_channels (board_id, &eeg_num_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[channel], data_count, (int)DetrendOperations::LINEAR);
std::pair<double *, double *> psd = DataFilter::get_psd_welch (data[channel], data_count,
fft_len, fft_len / 2, sampling_rate, (int)WindowFunctions::HANNING);
// calc band power
double band_power_alpha = DataFilter::get_band_power (psd, fft_len / 2 + 1, 7.0, 13.0);
double band_power_beta = DataFilter::get_band_power (psd, fft_len / 2 + 1, 14.0, 30.0);
std::cout << "alpha/beta:" << band_power_alpha / band_power_beta << std::endl;
// fail test if unexpected ratio
if (band_power_alpha / band_power_beta < 100)
{
res = -1;
}
delete[] psd.first;
delete[] psd.second;
}
catch (const BrainFlowException &err)
{
BoardShim::log_message ((int)LogLevels::LEVEL_ERROR, err.what ());
res = err.exit_code;
}
if (data != NULL)
{
for (int i = 0; i < num_rows; i++)
{
delete[] data[i];
}
}
delete[] data;
delete[] eeg_channels;
delete board;
return res;
}
C++ EEG Metrics¶
#include <chrono>
#include <iostream>
#include <stdlib.h>
#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;
using namespace std::chrono;
bool parse_args (int argc, char *argv[], struct BrainFlowInputParams *params, int *board_id);
int main (int argc, char *argv[])
{
struct BrainFlowInputParams params;
int board_id = 0;
if (!parse_args (argc, argv, ¶ms, &board_id))
{
return -1;
}
BoardShim::enable_dev_board_logger ();
BoardShim *board = new BoardShim (board_id, params);
double **data = NULL;
int *eeg_channels = NULL;
int num_rows = 0;
int res = 0;
int master_board_id = board->get_board_id ();
int sampling_rate = BoardShim::get_sampling_rate (master_board_id);
try
{
// Collect data from device
board->prepare_session ();
board->start_stream ();
BoardShim::log_message ((int)LogLevels::LEVEL_INFO, "Start sleeping in the main thread");
// recommended window size for eeg metric calculation is at least 4 seconds, bigger is
// better
#ifdef _WIN32
Sleep (5000);
#else
sleep (5);
#endif
int data_count = 0;
data = board->get_board_data (&data_count);
board->stop_stream ();
std::cout << "Data Count: " << data_count << std::endl;
board->release_session ();
num_rows = BoardShim::get_num_rows (master_board_id);
// Calc bandpowers and build feature vector
int eeg_num_channels = 0;
eeg_channels = BoardShim::get_eeg_channels (master_board_id, &eeg_num_channels);
std::pair<double *, double *> bands = DataFilter::get_avg_band_powers (
data, data_count, eeg_channels, eeg_num_channels, sampling_rate, true);
double feature_vector[10];
for (int i = 0; i < 5; i++)
{
feature_vector[i] = bands.first[i];
feature_vector[i + 5] = bands.second[i];
}
for (int i = 0; i < 10; i++)
{
std::cout << feature_vector[i] << " ";
}
std::cout << std::endl;
// Testing all classifiers and metric types
struct BrainFlowModelParams conc_model_params ((int)BrainFlowMetrics::CONCENTRATION, (int)BrainFlowClassifiers::REGRESSION);
MLModel concentration_model (conc_model_params);
concentration_model.prepare ();
std::cout << "Concentration Regression :" << concentration_model.predict (feature_vector, 10) << std::endl;
concentration_model.release ();
struct BrainFlowModelParams relax_model_params ((int)BrainFlowMetrics::RELAXATION, (int)BrainFlowClassifiers::KNN);
MLModel relaxation_model (relax_model_params);
relaxation_model.prepare ();
std::cout << "Relaxation KNN :" << relaxation_model.predict (feature_vector, 10) << std::endl;
relaxation_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 (data != NULL)
{
for (int i = 0; i < num_rows; i++)
{
delete[] data[i];
}
}
delete[] data;
delete[] eeg_channels;
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;
}
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 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))
board_shim$release_session ()
brainflow_python$DataFilter$write_file (data, "test.csv", "w")
data_restored <- brainflow_python$DataFilter$read_file ("test.csv")
print (restored_data)
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$WindowFunctions$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)
bands <- brainflow_python$DataFilter$get_avg_band_powers (data, eeg_channels, sampling_rate, TRUE)
feature_vector <- np$array(c(bands[[1]], bands[[2]]))
concentration_params <- brainflow_python$BrainFlowModelParams (brainflow_python$BrainFlowMetrics$CONCENTRATION$value, brainflow_python$BrainFlowClassifiers$REGRESSION$value)
concentration <- brainflow_python$MLModel (concentration_params)
concentration$prepare()
score <- concentration$predict(feature_vector)
concentration$release()
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);
board_shim.prepare_session ();
a = board_shim.config_board ('~6');
board_shim.start_stream (45000, '');
pause (5);
board_shim.stop_stream ();
data = board_shim.get_current_board_data (10);
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);
board_shim.prepare_session ();
board_shim.start_stream (45000, '');
pause (2)
board_shim.stop_stream ()
data = board_shim.get_current_board_data (20);
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);
sampling_rate = BoardShim.get_sampling_rate (int32 (BoardIDs.SYNTHETIC_BOARD));
board_shim.prepare_session ();
board_shim.start_stream (45000, '');
pause (5);
board_shim.stop_stream ();
data = board_shim.get_current_board_data (DataFilter.get_nearest_power_of_two (sampling_rate));
board_shim.release_session ();
eeg_channels = BoardShim.get_eeg_channels (int32 (BoardIDs.SYNTHETIC_BOARD));
% 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, 'db4', 2);
restored_data = DataFilter.perform_inverse_wavelet_transform (wavelet_data, wavelet_lenghts, size (original_data, 2), 'db4', 2);
% fft for first eeg channel %
fft_data = DataFilter.perform_fft (original_data, int32 (WindowFunctions.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);
board_shim.prepare_session ();
board_shim.start_stream (45000, '');
pause (5);
board_shim.stop_stream ();
data = board_shim.get_current_board_data (64);
board_shim.release_session ();
eeg_channels = BoardShim.get_eeg_channels (int32 (BoardIDs.SYNTHETIC_BOARD));
% 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));
filtered_data = DataFilter.perform_lowpass (original_data, sampling_rate, 10.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);
board_shim.prepare_session ();
board_shim.start_stream (45000, '');
pause (5);
board_shim.stop_stream ();
data = board_shim.get_current_board_data (64);
board_shim.release_session ();
eeg_channels = BoardShim.get_eeg_channels (int32 (BoardIDs.SYNTHETIC_BOARD));
% 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, 'db4', 2);
Matlab Band Power¶
BoardShim.set_log_file ('brainflow.log');
BoardShim.enable_dev_board_logger ();
params = BrainFlowInputParams ();
board_shim = BoardShim (int32 (BoardIDs.SYNTHETIC_BOARD), params);
sampling_rate = BoardShim.get_sampling_rate (int32 (BoardIDs.SYNTHETIC_BOARD));
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.release_session ();
eeg_channels = BoardShim.get_eeg_channels (int32 (BoardIDs.SYNTHETIC_BOARD));
eeg_channel = eeg_channels (2);
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 (WindowFunctions.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');
BoardShim.enable_dev_board_logger ();
params = BrainFlowInputParams ();
board_shim = BoardShim (int32 (BoardIDs.SYNTHETIC_BOARD), params);
sampling_rate = BoardShim.get_sampling_rate (int32 (BoardIDs.SYNTHETIC_BOARD));
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.release_session ();
eeg_channels = BoardShim.get_eeg_channels (int32 (BoardIDs.SYNTHETIC_BOARD));
[avgs, stddevs] = DataFilter.get_avg_band_powers (data, eeg_channels, sampling_rate, true);
feature_vector = double([avgs, stddevs]);
concentration_params = BrainFlowModelParams (int32(BrainFlowMetrics.CONCENTRATION), int32(BrainFlowClassifiers.REGRESSION));
concentration = MLModel (concentration_params);
concentration.prepare ();
score = concentration.predict (feature_vector);
concentration.release ();
Julia¶
Julia Get Data from a Board¶
import brainflow
# specify logging library to use
brainflow.enable_dev_brainflow_logger(Integer(brainflow.BOARD_CONTROLLER))
params = brainflow.BrainFlowInputParams()
board_shim = brainflow.BoardShim(Integer(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 Read Write File¶
import brainflow
# specify logging library to use
brainflow.enable_dev_brainflow_logger(Integer(brainflow.BOARD_CONTROLLER))
params = brainflow.BrainFlowInputParams()
board_shim = brainflow.BoardShim(Integer(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)
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¶
import brainflow
# enable logs
brainflow.enable_dev_brainflow_logger(Integer(brainflow.BOARD_CONTROLLER))
brainflow.enable_dev_brainflow_logger(Integer(brainflow.DATA_HANDLER))
params = brainflow.BrainFlowInputParams()
board_shim = brainflow.BoardShim(Integer(brainflow.SYNTHETIC_BOARD), params)
sampling_rate = brainflow.get_sampling_rate(Integer(brainflow.SYNTHETIC_BOARD))
brainflow.prepare_session(board_shim)
brainflow.start_stream(board_shim)
sleep(5)
brainflow.stop_stream(board_shim)
data = brainflow.get_current_board_data(brainflow.get_nearest_power_of_two(sampling_rate), board_shim)
brainflow.release_session(board_shim)
eeg_channels = brainflow.get_eeg_channels(Integer(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, "db4", 2)
restored_wavelet_data = brainflow.perform_inverse_wavelet_transform(wavelet_data, length(data_first_channel), "db4", 2)
fft_data = brainflow.perform_fft(data_first_channel, Integer(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¶
import brainflow
# specify logging library to use
brainflow.enable_dev_brainflow_logger(Integer(brainflow.BOARD_CONTROLLER))
params = brainflow.BrainFlowInputParams()
board_shim = brainflow.BoardShim(Integer(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(Integer(brainflow.SYNTHETIC_BOARD))
sampling_rate = brainflow.get_sampling_rate(Integer(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, 10.0, 3, Integer(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, 5.0, 3, Integer(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, 25.0, 20.0, 3, Integer(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, 50.0, 2.0, 3, Integer(brainflow.BESSEL), 0.0)
println("After BandStop Filter")
println(data_fourth_channel)
Julia Denoising¶
import brainflow
# specify logging library to use
brainflow.enable_dev_brainflow_logger(Integer(brainflow.BOARD_CONTROLLER))
params = brainflow.BrainFlowInputParams()
board_shim = brainflow.BoardShim(Integer(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(Integer(brainflow.SYNTHETIC_BOARD))
sampling_rate = brainflow.get_sampling_rate(Integer(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, Integer(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, "db4", 2)
println("After Wavelet Denoising")
println(data_second_channel)
Julia Band Power¶
import brainflow
# specify logging library to use
brainflow.enable_dev_brainflow_logger(Integer(brainflow.BOARD_CONTROLLER))
params = brainflow.BrainFlowInputParams()
board_shim = brainflow.BoardShim(Integer(brainflow.SYNTHETIC_BOARD), params)
sampling_rate = brainflow.get_sampling_rate(Integer(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(Integer(brainflow.SYNTHETIC_BOARD))
# 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, Integer(brainflow.LINEAR))
# psd is a tuple of ampls and freqs
psd = brainflow.get_psd_welch(data_second_channel, nfft, Integer(nfft / 2), sampling_rate, Integer(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¶
import brainflow
# enable all possible logs from all three libs
brainflow.enable_dev_brainflow_logger(Integer(brainflow.BOARD_CONTROLLER))
brainflow.enable_dev_brainflow_logger(Integer(brainflow.DATA_HANDLER))
brainflow.enable_dev_brainflow_logger(Integer(brainflow.ML_MODULE))
params = brainflow.BrainFlowInputParams()
board_shim = brainflow.BoardShim(Integer(brainflow.SYNTHETIC_BOARD), params)
sampling_rate = brainflow.get_sampling_rate(Integer(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(Integer(brainflow.SYNTHETIC_BOARD))
bands = brainflow.get_avg_band_powers(data, eeg_channels, sampling_rate, true)
feature_vector = vcat(bands[1], bands[2])
# calc concentration
model_params = brainflow.BrainFlowModelParams(Integer(brainflow.CONCENTRATION), Integer(brainflow.KNN))
concentration = brainflow.MLModel(model_params)
brainflow.prepare(concentration)
print(brainflow.predict(feature_vector, concentration))
brainflow.release(concentration)
# calc relaxation
model_params = brainflow.BrainFlowModelParams(Integer(brainflow.RELAXATION), Integer(brainflow.REGRESSION))
relaxation = brainflow.MLModel(model_params)
brainflow.prepare(relaxation)
print(brainflow.predict(feature_vector, relaxation))
brainflow.release(relaxation)