def denoise(sample, num_channels=16):
for channel in range(num_channels):
DataFilter.perform_rolling_filter(sample[0][channel], 3,
AggOperations.MEDIAN.value)
DataFilter.perform_wavelet_denoising(sample[0][channel], 'db6', 3)
sample = sample / np.expand_dims(sample.std(axis=-1), axis=-1)
return sample
def rolling_filter(self, data, parameter_list):
filter_data = []
for i in range(parameter_list[-1]):
DataFilter.perform_rolling_filter(data[i], parameter_list[1],
parameter_list[2])
filter_data.append(data[i])
filter_data = np.array(filter_data)
return filter_data
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)
else:
DataFilter.remove_environmental_noise(
data[channel], BoardShim.get_sampling_rate(board_id),
NoiseTypes.FIFTY.value)
df = pd.DataFrame(np.transpose(data))
plt.figure()
df[eeg_channels].plot(subplots=True)
plt.savefig('after_processing.png')
def denoise_data_pre_raw(self, data, denoise_method):
for channel in self.eeg_info[0]:
if denoise_method == 'mean':
DataFilter.perform_rolling_filter(data[channel], 3,
AggOperations.MEAN.value)
elif denoise_method == 'median':
DataFilter.perform_rolling_filter(data[channel], 3,
AggOperations.MEDIAN.value)
else:
DataFilter.perform_wavelet_denoising(data[channel],
denoise_method, 3)
return data
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')
def main ():
params = BrainFlowInputParams ()
params.board_id = 1
board_id = 1
params.serial_port = 'COM3'
sampling_rate = BoardShim.get_sampling_rate (board_id)
time_thres = 100
max_val = -100000000000
vals_mean = 0
num_samples = 5000
samples = 0
BoardShim.enable_dev_board_logger ()
board = BoardShim (board_id, params)
board.prepare_session ()
if board_id == brainflow.board_shim.BoardIds.GANGLION_BOARD.value:
board.config_board ('x1060000X')
board.start_stream (45000)
print("starting calibration")
time.sleep(5)
data = board.get_board_data()
print("start blinking")
while(samples < num_samples):
data = board.get_board_data()
if(len(data[1]) > 0):
DataFilter.perform_rolling_filter (data[1], 2, AggOperations.MEAN.value)
vals_mean += sum([data[1,i]/num_samples for i in range(len(data[1]))])
samples += len(data[1])
if(np.amax(data[1]) > max_val):
max_val = np.amax(data[1])
blink_thres = 0.5*((max_val - vals_mean)**2)
print("mean value")
print(vals_mean)
print("max value")
print(max_val)
print("threshold")
print(blink_thres)
print("CALIBRATION DONE START PLAYING")
prev_time = int(round(time.time() * 1000))
while True:
data = board.get_board_data()
if(len(data[1]) > 0):
DataFilter.perform_rolling_filter (data[1], 2, AggOperations.MEAN.value)
if((int(round(time.time() * 1000)) - time_thres) > prev_time):
prev_time = int(round(time.time() * 1000))
for element in data[1]:
if(((element - vals_mean)**2) >= blink_thres):
pydirectinput.press('space')
break
board.stop_stream ()
board.release_session ()
