'''This file summarizes the results from an extended noise test.
It uses the HTML report log generated at the end of the test as input.
It will output a summary in the same directory as the input report log,
as well as a graphic representation.
Usage: python noise_summary.py report.html
'''
from HTMLParser import HTMLParser
import matplotlib.pyplot as plt
import os.path
import re
import sys
# Constants
CORRECT_NUM_FINGERS = 1
CORRECT_MAX_DISTANCE = 1.0
FINGERS_INDEX = 0
DISTANCE_INDEX = 1
# A parser to consolidate the data in the html report
class ParseReport(HTMLParser):
def __init__(self, num_iterations):
HTMLParser.__init__(self)
self.curr_freq = 0
self.last_freq = self.curr_freq
self.curr_dict_index = 0
self.miscounted_fingers = 0
self.over_distance = 0
self.num_iterations = num_iterations
self.data_dict_list = []
for x in range(0, self.num_iterations):
# Each dictionary in the list represents
# one iteration of data
self.data_dict_list.append({})
# extracts the frequency from a line in the html report like this:
# noise_stationary_extended.
# ('0Hz', 'max_amplitude', 'square_wave', 'center')
def _extract_frequency(self, data):
return int(re.findall(r'\d+', data)[0])
# extracts the tids from a line in the html report like this:
# count of trackid IDs: 1
# criteria: == 1
def _extract_num_ids(self, data):
return float(re.findall(r'\d+', data)[0])
# extracts the distance from a line in the html report like this:
# Max distance slot0: 0.00 mm
# criteria: <= 1.0
def _extract_distance(self, data):
return float(re.findall(r'[-+]?\d*\.\d+|\d+', data)[0])
# Add the value read to the dictionary.
def _update_data_dict(self, value, val_index):
curr_freq = self.curr_freq
if curr_freq not in self.data_dict_list[self.curr_dict_index]:
self.data_dict_list[self.curr_dict_index][curr_freq] = [None, None]
self.data_dict_list[self.curr_dict_index][curr_freq][val_index] = value
# Handler for HTMLParser for whenever it encounters text between tags
def handle_data(self, data):
# Get the current frequency
if 'noise_stationary_extended' in data:
self.curr_freq = self._extract_frequency(data)
# Update the current iteration we're on.
if self.curr_freq == self.last_freq:
self.curr_dict_index = self.curr_dict_index + 1
else:
self.last_freq = self.curr_freq
self.curr_dict_index = 0
# Update number of fingers data
if 'count of trackid IDs:' in data:
num_ids = self._extract_num_ids(data)
if num_ids != CORRECT_NUM_FINGERS:
self.miscounted_fingers = self.miscounted_fingers + 1
self._update_data_dict(num_ids, FINGERS_INDEX)
else:
self._update_data_dict(None, FINGERS_INDEX)
# Update maximum distance data
if 'Max distance' in data:
distance = self._extract_distance(data)
if distance > CORRECT_MAX_DISTANCE:
self.over_distance = self.over_distance + 1
self._update_data_dict(distance, DISTANCE_INDEX)
else:
self._update_data_dict(None, DISTANCE_INDEX)
# A parser to count the number of iterations
class CountIterations(ParseReport):
def __init__(self):
ParseReport.__init__(self, num_iterations=0)
self.counting_iterations = True
# Handler for HTMLParser for whenever it encounters text between tags
def handle_data(self, data):
# Get the current frequency
if 'noise_stationary_extended' in data:
self.curr_freq = self._extract_frequency(data)
if self.counting_iterations:
if self.curr_freq == self.last_freq:
self.num_iterations = self.num_iterations + 1
else:
self.counting_iterations = False
# A weighting function to determine how badly
# a frequency failed. It outputs the total number
# of errors, where each misread or additionally read
# finger counts as one error, and each 0.2mm over the
# maximum distance counts as one error.
def weighting_function(data):
num_fingers = data[FINGERS_INDEX]
max_dist = data[DISTANCE_INDEX]
if num_fingers is None:
num_fingers = CORRECT_NUM_FINGERS
if max_dist is None:
max_dist = 0
finger_val = abs(num_fingers - CORRECT_NUM_FINGERS)
dist_val = 5 * (max_dist - CORRECT_MAX_DISTANCE)
dist_val = 0 if dist_val < 0 else dist_val
return finger_val + dist_val
# Returns a list of frequencies in order of how
# 'badly' they failed
def value_sorted_freq(data_dict):
list_of_tuples = sorted(data_dict.iteritems(), reverse=True,
key=lambda (k, v): weighting_function(v))
return [i[0] for i in list_of_tuples]
# Print out the summary of results for a single iteration,
# ordered by how badly each frequency failed.
def print_iteration_summary(data_dict, iteration, outfile):
outfile.write('\n')
outfile.write("Iteration %d\n" % iteration)
outfile.write('-------------\n')
for freq in value_sorted_freq(data_dict):
num_fingers = data_dict[freq][FINGERS_INDEX]
max_dist = data_dict[freq][DISTANCE_INDEX]
# Don't output anything if there was no error
if num_fingers is None and max_dist is None:
continue
else:
num_fingers = '' if num_fingers is None else '%s tids' % num_fingers
max_dist = '' if max_dist is None else '%s mm' % max_dist
outfile.write('{:,}Hz \t %s \t %s \n'.format(freq) %
(num_fingers, max_dist))
# Print out a summary of errors for each iteration
def print_summary(parse_report, output_file):
outfile = open(output_file, 'w')
outfile.write('Summary: \n')
outfile.write(' %d issues with finger tracking over all iterations. \n' %
parse_report.miscounted_fingers)
outfile.write(' %d issues with distance over all iterations. \n' %
parse_report.over_distance)
outfile.write('\n\n')
outfile.write('Worst frequencies:\n')
for iteration, data_dict in enumerate(parse_report.data_dict_list):
print_iteration_summary(data_dict, iteration, outfile)
outfile.close()
# For each iteration, generate a subplot
def show_graph(parse_report):
for iteration, data_dict in enumerate(parse_report.data_dict_list):
sorted_by_freq = sorted(parse_report.data_dict_list[iteration].items())
frequencies = [i[0] for i in sorted_by_freq]
values = [weighting_function(i[1]) for i in sorted_by_freq]
plt.subplot(parse_report.num_iterations, 1, iteration)
plt.plot(frequencies, values)
plt.xlabel('Frequency (Hz)')
plt.ylabel('Number of problems')
plt.legend(("Iteration %d" % iteration,))
plt.title('Graphic Summary of Extended Noise Test')
plt.show()
def main():
# Error checking
if len(sys.argv) != 2:
print 'Usage: python noise_summary.py report.html'
return
input_file = sys.argv[1]
if '.html' not in input_file:
print 'File must be an html firmware report.'
print 'An example report name is:'
print 'touch_firmware_report-swanky-fw_2.0-noise-20140826_173022.html'
return
# Create filepaths
directory = os.path.dirname(input_file)
output_file = '%s_summary.txt' % \
os.path.splitext(os.path.basename(input_file))[0]
output_path = os.path.join(directory, output_file)
try:
html_file = open(input_file)
except:
print '%s could not be found.' % input_file
return
# Parse the report
html = html_file.read()
c = CountIterations()
c.feed(html)
p = ParseReport(c.num_iterations)
p.feed(html)
html_file.close()
p.close()
# Display the result
print_summary(p, output_path)
print 'The summary has been saved to %s' % output_path
show_graph(p)
if __name__ == '__main__':
main()