def glass_ratio(statistics_subdir, filename, vlc_evaluation_w,
vlc_evaluation_wo):
data = "### Without glass\n"
data += "throughput\n"
data += utils.statistics.get_summary(
vlc_evaluation_wo.get_throughput()) + "\n"
data += "---\n"
data += "error\n"
data += utils.statistics.get_summary(vlc_evaluation_wo.get_error()) + "\n"
data += "---\n"
data += "### With glass\n"
data += "throughput\n"
data += utils.statistics.get_summary(
vlc_evaluation_w.get_throughput()) + "\n"
data += "---\n"
data += "error\n"
data += utils.statistics.get_summary(vlc_evaluation_w.get_error()) + "\n"
data += "---\n"
data += "### Ratio\n"
data += "throughput: "
data += str(
ratio(vlc_evaluation_wo.get_throughput(),
vlc_evaluation_w.get_throughput())) + "\n"
data += "error: "
data += str(
ratio(vlc_evaluation_wo.get_error(), vlc_evaluation_w.get_error()))
misc.log(data, statistics_subdir, filename)
def print_statistics_ambient_light(data_directory, ambient_light):
for led, ambient_light_intensities in ambient_light.items():
output = ""
for ambient_light, values in ambient_light_intensities.items():
output += ambient_light + "\n"
output += statistics.get_summary(values) + "\n"
output += "------------------------------\n"
filename = "ambient_light_" + led
misc.log(output, data_directory, filename)
def print_statistics(statistics_subdir, filename, data):
throughput = list()
error = list()
for performance in data.values():
throughput.extend(performance.get_throughput())
error.extend(performance.get_error())
data = "### Throughput" + "\n" + \
statistics.get_summary(throughput) + "\n" + \
"------------------------\n" + \
"### Error" + "\n" + \
statistics.get_summary(error)
misc.log(data, statistics_subdir, filename)
def plot_evaluation_rounds(result_directory,
statistics_subdir,
min_latency,
max_latency,
stop_keyword="light_intensity"):
latency = dict()
for f in os.listdir(result_directory):
if stop_keyword not in f:
path = result_directory + f
vlc_evaluation = DillSerializer(path).deserialize()
latency[f] = vlc_evaluation.get_latency()
data = latency_statistics(f, vlc_evaluation.get_latency())
misc.log(data, statistics_subdir, f)
latency_plot(statistics_subdir, latency, min_latency, max_latency)
def print_ratio(subdir, filename, data):
low = data[0].get_data_series()
mid = data[1].get_data_series()
high = data[2].get_data_series()
def get_statistic(data_series):
return round(numpy.mean(data_series), 2), round(numpy.std(data_series), 2)
def get_statistic_line(mean, std):
return "mean: " + str(mean) + ", std: " + str(std)
output = "low\n"
mean, std = get_statistic(low)
output += get_statistic_line(mean, std) + "\n"
output += "mid\n"
mean, std = get_statistic(mid)
output += get_statistic_line(mean, std) + "\n"
output += "high\n"
mean, std = get_statistic(high)
output += get_statistic_line(mean, std) + "\n"
misc.log(output, subdir, filename)
def orientation_performance(result_directory, statistics_subdir):
min_throughput = -50
min_error = -0.008
max_throughput, max_error = parameters.get_max_throughput_error(
result_directory)
for f in os.listdir(result_directory):
path = result_directory + f
vlc_evaluation = DillSerializer(path).deserialize()
parameters.throughput_error_plot(
statistics_subdir,
f,
vlc_evaluation.get_throughput(),
vlc_evaluation.get_error(),
vlc_evaluation.duration_data, #vlc_evaluation.get_data_period(),
min_throughput,
max_throughput,
min_error,
max_error)
data = parameters.throughput_error_statistics(
f, vlc_evaluation.get_throughput(), vlc_evaluation.get_error())
misc.log(data, statistics_subdir, f)
def main():
data_directory = "vlc_distance/"
result_directory = files.dir_results + data_directory
statistics_subdir = data_directory
distance_directed_led = dict()
distance_pervasive_led = dict()
for f in os.listdir(result_directory):
if "light_intensity" in f:
path = result_directory + f
light_intensity = [item["intensity"] for item in misc.read_json(open(path))]
data = statistics.get_summary(light_intensity)
misc.log(data, statistics_subdir, f)
elif "morse" in f:
distance = get_distance(f)
path = result_directory + f
vlc_evaluation = DillSerializer(path).deserialize()
if "directed_led" in f:
distance_directed_led[distance] = vlc_evaluation
elif "pervasive_led" in f:
distance_pervasive_led[distance] = vlc_evaluation
min_throughput = -50
min_error = -0.008
max_throughput_pervasive, max_error_pervasive = find_max_throughput_error(distance_pervasive_led)
max_throughput_directed, max_error_directed = find_max_throughput_error(distance_directed_led)
max_throughput = max(max_throughput_pervasive, max_throughput_directed)
max_error = max(max_error_pervasive, max_error_directed)
filename = "directed_led"
throughput_error_plot(statistics_subdir, filename, distance_directed_led, 4.30,
min_throughput, max_throughput, min_error, max_error)
print_statistics(statistics_subdir, filename, distance_directed_led)
filename = "pervasive_led"
throughput_error_plot(statistics_subdir, filename, distance_pervasive_led, 1.60,
min_throughput, max_throughput, min_error, max_error)
print_statistics(statistics_subdir, filename, distance_pervasive_led)