import re
import matplotlib.pyplot as plt
import matplotlib.colors as colors
import pywt
from time_features import FEATURES
import noise_reduction
import file_helpers
ale_values = list(
map(
lambda x: file_helpers.get_values_from_file(x),
file_helpers.get_all_files(
'collected_data/passwords/alejandro/**/*.json')))
luis_values = list(
map(lambda x: file_helpers.get_values_from_file(x),
file_helpers.get_all_files('collected_data/passwords/luis/**/*.json')))
def _pre_process_signal(values):
return noise_reduction.filter_emg_signal(values)
def extract_feature(feature_name, raw_data):
return FEATURES[feature_name](_pre_process_signal(raw_data))
if __name__ == '__main__':
feature_idx = 0
for feature_name, feature in FEATURES.items():
import math
import random
import numpy as np
import noise_reduction
import file_helpers
from time_features import FEATURES
ale_files = list(map(lambda x: file_helpers.get_values_from_file(x), file_helpers.get_all_files('collected_data/passwords/alejandro/**/*.json')))
luis_files = list(map(lambda x: file_helpers.get_values_from_file(x), file_helpers.get_all_files('collected_data/passwords/luis/**/*.json')))
people = {}
def _calculate_probability(x, mean, stdev):
exponent = math.exp(-(math.pow(x - mean, 2) / (2 * math.pow(stdev, 2))))
return (1 / (math.sqrt(2 * math.pi) * stdev)) * exponent
def prediction(person, signal):
probabilities = []
for feature_name, feature in FEATURES.items():
feat = FEATURES[feature_name](signal)
mean = people[person][feature_name]['mean']
std = people[person][feature_name]['std']
probabilities.append(_calculate_probability(feat, mean, std))
return probabilities
def train(person, train_data):
# Add person if missing
def _calculate_average_features():
result = {
'ale': {
'values': list(map(lambda x: file_helpers.get_values_from_file(x), ale_files)),
'features': {}
},
'luis': {
'values': list(map(lambda x: file_helpers.get_values_from_file(x), luis_files)),
'features': {}
}
}
wavelets = ['sym5', 'bior6.8', 'db1', 'db2']
threshold_modes = ['hard', 'soft']
thresholds = np.arange(0.1, 11.0, 0.1)
wavelet_levels = [None, 4]
# First get the features without noise reduction
for feature_name, feature in FEATURES.items():
for person, info in result.items():
features = list(map(lambda x: FEATURES[feature_name](x), info['values']))
if feature_name not in info['features']:
info['features'][feature_name] = {}
info['features'][feature_name]['raw'] = np.mean(features)
# Now calculate the features with noise reduction
for wavelet in wavelets:
for threshold_mode in threshold_modes:
for threshold in thresholds:
for wavelet_level in wavelet_levels:
# Calculate the averages
for feature_name, feature in FEATURES.items():
for person, info in result.items():
features = list(
map(
lambda filtered_signal: FEATURES[feature_name](filtered_signal),
map(
lambda original_signal: filter_emg_signal(
original_signal, wavelet=wavelet, threshold_mode=threshold_mode, threshold_value=threshold, wavelet_level=wavelet_level
),
info['values']
)
)
)
info['features'][feature_name]['{} - {} - {} - {}'.format(wavelet, threshold_mode, threshold, wavelet_level)] = np.mean(features)
people = list(result.keys())
features = list(FEATURES.keys())
variants = list(result[people[0]]['features'][features[0]].keys())
for feature in features:
max_diff = 0
max_variant = None
for variant in variants:
averages = []
for person in people:
averages.append(result[person]['features'][feature][variant])
min_diff = _find_min_diff(averages)
if min_diff > max_diff:
max_diff = min_diff
max_variant = variant
print('Feature: {} best variant is: {}'.format(feature, max_variant))
def _pre_process_signal(data):
# TODO: filter signal
return data
def extract_feature(feature_name, raw_data):
return FEATURES[feature_name](
_pre_process_signal(raw_data)
)
if __name__ == '__main__':
x = range(0, len(DATA_MOVEMENTS))
for feature_name, feature in FEATURES.items():
for idx, movement in enumerate(DATA_MOVEMENTS):
plt.title('Feature {} for placement {}'.format(feature_name, PLACEMENT))
files = file_helpers.files_matching(movement)
features = list(
map(lambda x: extract_feature(feature_name, file_helpers.get_values_from_file(x)), files)
)
plt.xticks(x, DATA_MOVEMENTS, rotation=45)
for y in features:
plt.scatter(idx, y, color=list(colors.cnames.values())[idx + 8])
plt.show()
min_diff = _find_min_diff(averages)
if min_diff > max_diff:
max_diff = min_diff
max_variant = variant
print('Feature: {} best variant is: {}'.format(feature, max_variant))
def _find_min_diff(arr):
# Sort array in non-decreasing order
arr = sorted(arr)
# Initialize difference as infinite
diff = 10 ** 20
# Find the min diff by comparing adjacent pairs in sorted array
for i in range(len(arr) - 1):
if arr[i + 1] - arr[i] < diff:
diff = arr[i + 1] - arr[i]
return diff
if __name__ == '__main__':
#_calculate_average_features()
original_signal = file_helpers.get_values_from_file(password_file)
filtered_signal = filter_emg_signal(original_signal, wavelet='sym5', threshold_value=3.0)
plot(original_signal, filtered_signal)