def plot_example(missed, acknowledged):
sensor_miss = import_sensorfile(missed)
sensor_ack = import_sensorfile(acknowledged)
# Window data
mag_miss = window_data(process_input(sensor_miss))
mag_ack = window_data(process_input(sensor_ack))
# Window data
mag_miss = window_data(process_input(sensor_miss))
mag_ack = window_data(process_input(sensor_ack))
# Filter setup
kernel = 15
# apply filter
mag_miss_filter = sci.medfilt(mag_miss, kernel)
mag_ack_filter = sci.medfilt(mag_ack, kernel)
# calibrate data
mag_miss_cal = mf.calibrate_median(mag_miss)
mag_miss_cal_filter = mf.calibrate_median(mag_miss_filter)
mag_ack_cal = mf.calibrate_median(mag_ack)
mag_ack_cal_filter = mf.calibrate_median(mag_ack_filter)
# PLOT
sns.set_style("white")
current_palette = sns.color_palette('muted')
sns.set_palette(current_palette)
plt.figure(0)
# Plot RAW missed and acknowledged reminders
ax1 = plt.subplot2grid((2, 1), (0, 0))
plt.ylim([-1.5, 1.5])
plt.ylabel('Acceleration (g)')
plt.plot(mag_miss_cal, label='Recording 1')
plt.legend(loc='lower left')
ax2 = plt.subplot2grid((2, 1), (1, 0))
# Plot Missed Reminder RAW
plt.ylim([-1.5, 1.5])
plt.ylabel('Acceleration (g)')
plt.xlabel('t (ms)')
plt.plot(mag_ack_cal, linestyle='-', label='Recording 2')
plt.legend(loc='lower left')
# CALC AND SAVE STATS
stats_one = sp.calc_stats_for_data_stream_as_dictionary(mag_miss_cal)
stats_two = sp.calc_stats_for_data_stream_as_dictionary(mag_ack_cal)
data = [stats_one, stats_two]
write_to_csv(data, 'example_waves')
plt.show()
def plot_singlewave(file):
sensor = import_sensorfile(file)
sensor_processed = process_input(sensor)
timestamps = []
[timestamps.append(str(item[0])) for item in sensor]
sensor_processed_calibrated = mf.calibrate_median(sensor_processed)
sensor_filtered = mf.medfilt(sensor_processed_calibrated, 3)
plt.plot(sensor_filtered, linewidth='0.8')
plt.xlim([0, 12000])
plt.ylim([-5, 5])
plt.ylabel('Acceleration (g)')
plt.xlabel('Time (ms)')
# plt.xticks(sensor_filtered, timestamps, rotation='vertical')
plt.show()
def process_triaxial(file_path, window_start_time, window_end_time):
with open(file_path) as csv_sensorfile:
# dictionary to hold features
features = {}
sensorfile = csv.reader(csv_sensorfile, delimiter=',', quotechar='|')
sensor_rows = []
for row in sensorfile:
# the correct format has 4 elements (avoids header and footer rows)
if len(row) == 4:
try:
timestamp = int(row[0])
x = float(row[1])
y = float(row[2])
z = float(row[3])
sensor_rows.append([timestamp, x, y, z])
except ValueError:
continue
# if no data exists generate empty stats
# otherwise calculate stats
if not sensor_rows:
features = produce_empty_triaxial_sensor_dict(features)
else:
# convert basic python lists to numPy arrays using slices
sensor_rows = np.array(sensor_rows)
# convert to list for sorting algorithm
timestamps = sensor_rows[:, 0].tolist()
# calculate window indexes
window_indexes = calculate_window_indexes(timestamps, window_start_time, window_end_time)
window_start_index = window_indexes[0]
window_end_index = window_indexes[1]
# validate window indexes
window_indexes_valid = window_index_conditions_valid(window_start_index, window_end_index)
# if valid, window the data, and calculate stats
if window_indexes_valid:
# make slices of data using indexes
x_win = sensor_rows[window_start_index:window_end_index, 1]
y_win = sensor_rows[window_start_index:window_end_index, 2]
z_win = sensor_rows[window_start_index:window_end_index, 3]
svm_win = get_magnitude(x_win, y_win, z_win)
# Pass through a median filter first using kernel of 21
kernel = 15 # must be an odd number
x_median_filter = mf.medfilt(x_win, kernel)
y_median_filter = mf.medfilt(y_win, kernel)
z_median_filter = mf.medfilt(z_win, kernel)
svm_median_filter = mf.medfilt(svm_win, kernel)
# Calibrate filtered SVM using min & median values
svm_median_filter_calibrated_min = mf.calibrate_minimum(svm_median_filter)
svm_median_filter_calibrated_med = mf.calibrate_median(svm_median_filter)
# calculate stats
stats_x = calc_stats_for_data_stream_as_dictionary(x_win)
stats_y = calc_stats_for_data_stream_as_dictionary(y_win)
stats_z = calc_stats_for_data_stream_as_dictionary(z_win)
stats_svm = calc_stats_for_data_stream_as_dictionary(svm_win)
stats_x_median_filter = calc_stats_for_data_stream_as_dictionary(x_median_filter)
stats_y_median_filter = calc_stats_for_data_stream_as_dictionary(y_median_filter)
stats_z_median_filter = calc_stats_for_data_stream_as_dictionary(z_median_filter)
stats_svm_median_filter = calc_stats_for_data_stream_as_dictionary(svm_median_filter)
stats_svm_median_filter_calibrated_min = calc_stats_for_data_stream_as_dictionary(
svm_median_filter_calibrated_min)
stats_svm_median_filter_calibrated_med = calc_stats_for_data_stream_as_dictionary(
svm_median_filter_calibrated_med)
features.update({'x': stats_x,
'y': stats_y,
'z': stats_z,
'svm': stats_svm,
'x_median_filter': stats_x_median_filter,
'y_median_filter': stats_y_median_filter,
'z_median_filter': stats_z_median_filter,
'svm_median_filter': stats_svm_median_filter,
'svm_median_filter_calibrated_min': stats_svm_median_filter_calibrated_min,
'svm_median_filter_calibrated_med': stats_svm_median_filter_calibrated_med
})
else:
features = produce_empty_triaxial_sensor_dict(features)
return features
def process_triaxial(file_path, window_start_time, window_end_time):
with open(file_path) as csv_sensorfile:
# dictionary to hold features
features = {}
sensorfile = csv.reader(csv_sensorfile, delimiter=',', quotechar='|')
sensor_rows = []
for row in sensorfile:
# the correct format has 4 elements (avoids header and footer rows)
if len(row) == 4:
try:
timestamp = int(row[0])
x = float(row[1])
y = float(row[2])
z = float(row[3])
sensor_rows.append([timestamp, x, y, z])
except ValueError:
continue
# if no data exists generate empty stats
# otherwise calculate stats
if not sensor_rows:
features = produce_empty_triaxial_sensor_dict(features)
else:
# convert basic python lists to numPy arrays using slices
sensor_rows = np.array(sensor_rows)
# convert to list for sorting algorithm
timestamps = sensor_rows[:, 0].tolist()
# calculate window indexes
window_indexes = calculate_window_indexes(timestamps,
window_start_time,
window_end_time)
window_start_index = window_indexes[0]
window_end_index = window_indexes[1]
# validate window indexes
window_indexes_valid = window_index_conditions_valid(
window_start_index, window_end_index)
# if valid, window the data, and calculate stats
if window_indexes_valid:
# make slices of data using indexes
x_win = sensor_rows[window_start_index:window_end_index, 1]
y_win = sensor_rows[window_start_index:window_end_index, 2]
z_win = sensor_rows[window_start_index:window_end_index, 3]
svm_win = get_magnitude(x_win, y_win, z_win)
# Pass through a median filter first using kernel of 21
kernel = 15 # must be an odd number
x_median_filter = mf.medfilt(x_win, kernel)
y_median_filter = mf.medfilt(y_win, kernel)
z_median_filter = mf.medfilt(z_win, kernel)
svm_median_filter = mf.medfilt(svm_win, kernel)
# Calibrate filtered SVM using min & median values
svm_median_filter_calibrated_min = mf.calibrate_minimum(
svm_median_filter)
svm_median_filter_calibrated_med = mf.calibrate_median(
svm_median_filter)
# calculate stats
stats_x = calc_stats_for_data_stream_as_dictionary(x_win)
stats_y = calc_stats_for_data_stream_as_dictionary(y_win)
stats_z = calc_stats_for_data_stream_as_dictionary(z_win)
stats_svm = calc_stats_for_data_stream_as_dictionary(svm_win)
stats_x_median_filter = calc_stats_for_data_stream_as_dictionary(
x_median_filter)
stats_y_median_filter = calc_stats_for_data_stream_as_dictionary(
y_median_filter)
stats_z_median_filter = calc_stats_for_data_stream_as_dictionary(
z_median_filter)
stats_svm_median_filter = calc_stats_for_data_stream_as_dictionary(
svm_median_filter)
stats_svm_median_filter_calibrated_min = calc_stats_for_data_stream_as_dictionary(
svm_median_filter_calibrated_min)
stats_svm_median_filter_calibrated_med = calc_stats_for_data_stream_as_dictionary(
svm_median_filter_calibrated_med)
features.update({
'x':
stats_x,
'y':
stats_y,
'z':
stats_z,
'svm':
stats_svm,
'x_median_filter':
stats_x_median_filter,
'y_median_filter':
stats_y_median_filter,
'z_median_filter':
stats_z_median_filter,
'svm_median_filter':
stats_svm_median_filter,
'svm_median_filter_calibrated_min':
stats_svm_median_filter_calibrated_min,
'svm_median_filter_calibrated_med':
stats_svm_median_filter_calibrated_med
})
else:
features = produce_empty_triaxial_sensor_dict(features)
return features
def plot_kernal_length_experiment(missed, acknowledged):
sensor_miss = import_sensorfile(missed)
sensor_ack = import_sensorfile(acknowledged)
# Window data
mag_miss = window_data(process_input(sensor_miss))
mag_ack = window_data(process_input(sensor_ack))
# Filter setup
difference = []
stats_output = []
for num in range(3, 63):
# check if odd
if num % 2 != 0:
kernel = num
# apply filter
mag_miss_filter = sci.medfilt(mag_miss, kernel)
mag_ack_filter = sci.medfilt(mag_ack, kernel)
# calibrate data
mag_miss_cal = mf.calibrate_median(mag_miss)
mag_miss_cal_filter = mf.calibrate_median(mag_miss_filter)
mag_ack_cal = mf.calibrate_median(mag_ack)
mag_ack_cal_filter = mf.calibrate_median(mag_ack_filter)
# STATS
# Calculate the stats for raw and windowed for each
stats_miss = sp.calc_stats_for_data_stream_as_dictionary(mag_miss_cal)
stats_miss_filter = sp.calc_stats_for_data_stream_as_dictionary(mag_miss_cal_filter)
stats_ack = sp.calc_stats_for_data_stream_as_dictionary(mag_ack_cal)
stats_ack_filter = sp.calc_stats_for_data_stream_as_dictionary(mag_ack_cal_filter)
stats_data = [stats_miss, stats_miss_filter, stats_ack, stats_ack_filter]
[data.pop("med", None) for data in stats_data]
print('Stats Missed:' + str(stats_miss))
print('Stats Acknowledged: ' + str(stats_ack))
print('Stats Missed Filtered: ' + str(stats_miss_filter))
print('Stats Acknowledged Filtered:' + str(stats_ack_filter))
# Calculate the percentage difference between the values
dif_stats_raw = calculate_difference(stats_miss, stats_ack)
dif_stats_filtered = calculate_difference(stats_miss_filter, stats_ack_filter)
print('Difference in RAW as percentage:' + str(dif_stats_raw))
print('Difference in FILTERED as percentage:' + str(dif_stats_filtered))
dif_stats_raw_overall = calcualate_meanfordictionary(dif_stats_raw)
dif_stats_filtered_overall = calcualate_meanfordictionary(dif_stats_filtered)
print('Avg. Difference RAW: ' + str(dif_stats_raw_overall))
print('Avg. Difference Filtered: ' + str(dif_stats_filtered_overall))
difference.append((kernel, dif_stats_filtered_overall))
if kernel == 15:
stats_output.append(stats_miss)
stats_output.append(stats_ack)
stats_output.append(stats_miss_filter)
stats_output.append(stats_ack_filter)
stats_output.append(dif_stats_raw)
stats_output.append(dif_stats_filtered)
write_to_csv(stats_output)
x_val = [x[0] for x in difference]
y_val = [x[1] for x in difference]
xticks = [str(x) for x in x_val]
base_val = [54] * 63
plt.xticks(x_val, xticks)
plt.xlabel('Window Length (k)')
plt.ylabel('Percentage Difference (%)')
plt.ylim([40, 140])
plt.plot(x_val, y_val, label='Median Filter')
plt.plot(base_val, linestyle='--', label='Baseline (Unfiltered)')
plt.legend(loc='lower right')
plt.show()
def plot_against(missed, acknowledged):
sensor_miss = import_sensorfile(missed)
sensor_ack = import_sensorfile(acknowledged)
# Window data
mag_miss = window_data(process_input(sensor_miss))
mag_ack = window_data(process_input(sensor_ack))
# Filter setup
kernel = 15
# apply filter
mag_miss_filter = sci.medfilt(mag_miss, kernel)
mag_ack_filter = sci.medfilt(mag_ack, kernel)
# calibrate data
mag_miss_cal = mf.calibrate_median(mag_miss)
mag_miss_cal_filter = mf.calibrate_median(mag_miss_filter)
mag_ack_cal = mf.calibrate_median(mag_ack)
mag_ack_cal_filter = mf.calibrate_median(mag_ack_filter)
# PLOT
ylimit_top = [-5, 10]
ylimits_filtered = [-4, 4]
ylimits_filtered_bottom = [-1.5, 1.5]
sns.set_style("darkgrid")
current_palette = sns.color_palette('muted')
sns.set_palette(current_palette)
plt.figure(0)
# Plot RAW missed and acknowledged reminders
ax1 = plt.subplot2grid((4, 2), (0, 0), colspan=2)
plt.ylim(ylimit_top)
raw_miss = plt.plot(mag_miss_cal, label='Missed (Unfiltered)')
raw_ack = plt.plot(mag_ack_cal, label='Acknowledged (Unfiltered)')
plt.legend(loc='upper left')
ax2 = plt.subplot2grid((4, 2), (1, 0))
# Plot Missed Reminder RAW
plt.ylim(ylimits_filtered)
plt.plot(mag_miss_cal, linestyle='-', label='Unfiltered')
plt.legend(loc='lower left')
ax3 = plt.subplot2grid((4, 2), (1, 1))
# Plot Acknow Reminder RAW
plt.ylim(ylimits_filtered)
plt.plot(mag_ack_cal, linestyle='-', label='Unfiltered')
plt.legend(loc='lower left')
ax4 = plt.subplot2grid((4, 2), (2, 0))
# Plot Missed Reminder Filter
plt.ylim(ylimits_filtered)
plt.plot(mag_miss_cal, linestyle=':', label='Unfiltered')
plt.plot(mag_miss_cal_filter, linestyle='-', label='Median Filter (k=' + str(kernel) + ')')
plt.legend(loc='lower left')
ax5 = plt.subplot2grid((4, 2), (2, 1))
# Plot Acknow Reminder Filter
plt.ylim(ylimits_filtered)
plt.plot(mag_ack_cal, linestyle=':', label='Unfiltered')
plt.plot(mag_ack_cal_filter, linestyle='-', label='Median Filter (k=' + str(kernel) + ')')
plt.legend(loc='lower left')
ax6 = plt.subplot2grid((4, 2), (3, 0), colspan=2)
plt.ylim(ylimits_filtered_bottom)
plt.style.use('grayscale')
plt.plot(mag_miss_cal_filter, label='Missed (Filtered)')
plt.plot(mag_ack_cal_filter, label='Acknowledged (Filtered)')
plt.legend(loc='lower left')
plt.suptitle("Applying Filters to Signals")
plt.show()
