hedgeski79942/EVM
1
0
Fork 0
Code Issues 9 Pull Requests 1 Releases Wiki Activity

Testauswertung zusammengeführt und in den Testablauf integriert

Browse Source 
In excel_processing habe ich nur den Funktionsaufruf der Evaluation hinzugefügt, die evaluation enthält die Funktionalitäten aus dem Testauswertung-Ordner
This commit is contained in:
Jonathan Frei 2024-01-11 12:52:43 +00:00
parent 7c2c8f1b4d
commit db476fbce2
2 changed files with 290 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
code/excel_evaluation.py Normal file
View File

@ -0,0 +1,151 @@
import openpyxl
def excel_row_to_string(file_path):
# Öffne die Excel-Datei
workbook = openpyxl.load_workbook(file_path)
# Wähle das Arbeitsblatt aus
sheet = workbook['Sheet1']
# Erhalte die angegebene Zeile als Liste von Zellen
row_values = [cell.value for cell in sheet[2]]
# Ergebnisse werden ab Spalte 5 eingetragen
selected_columns = list(range(4, len(row_values)))
# Wähle nur die gewünschten Spalten aus
selected_values = [row_values[col] for col in selected_columns]
# Schließe die Excel-Datei
workbook.close()
# Konvertiere die Liste von Zellen in einen String
row_string = ', '.join(str(value) for value in selected_values)
return row_string
def write_subdivided_string_to_excel(file_path, input_string):
# Öffne die Excel-Datei
workbook = openpyxl.load_workbook(file_path)
# Wähle das Arbeitsblatt aus
sheet = workbook['Sheet1']
# Teile den String nach jedem Komma auf
parts = input_string.split(',')
# Trage jeden Teil des Strings in eine neue Zeile ein
for i, part in enumerate(parts, 1):
#Spalte 17 kann sich je nach Tabellenstruktur ändern!
sheet.cell(row=2 + i - 1, column=17, value=part.strip()) # strip entfernt mögliche Leerzeichen
# Speichere die Änderungen
workbook.save(file_path)
# Schließe die Excel-Datei
workbook.close()
def read_columns(file_path):
# Öffne die Excel-Datei
workbook = openpyxl.load_workbook(file_path)
# Wähle das Arbeitsblatt aus
sheet = workbook['Sheet1']
# Lese die Werte der beiden Spalten aus
values_column1 = [cell.value for cell in sheet['O']][1:]
values_column2 = [cell.value for cell in sheet['Q']][1:]
# Schließe die Excel-Datei
workbook.close()
return values_column1, values_column2
def calculate_deviation(liste1, liste2):
# Überprüfe, ob die Listen die gleiche Länge haben
if len(liste1) != len(liste2):
raise ValueError("Die Listen müssen die gleiche Länge haben")
# Berechne die prozentuale Abweichung zwischen den Werten
deviations = [((abs(float(b) - float(a)) / float(a)) * 100) if float(a) != 0 else None for a, b in zip(liste1, liste2)]
return deviations
def write_string_to_excel(file_path, input_string, column):
# Öffne die Excel-Datei
workbook = openpyxl.load_workbook(file_path)
# Wähle das Arbeitsblatt aus
sheet = workbook['Sheet1']
# Trage jeden Buchstaben des Strings in eine eigene Zeile ein
for i, char in enumerate(input_string, 1):
sheet.cell(row=2 + i - 1, column=column, value=char)
# Speichere die Änderungen
workbook.save(file_path)
# Schließe die Excel-Datei
workbook.close()
def copy_header(input_sheet, output_sheet):
# Kopiere den Header manuell in das Ausgabe-Arbeitsblatt
for row in input_sheet.iter_rows(min_row=1, max_row=1, values_only=True):
output_sheet.append(row)
def sort_excel(input_file_path, output_file_path, ):
# Öffne die Eingabe-Excel-Datei
input_workbook = openpyxl.load_workbook(input_file_path)
input_sheet = input_workbook['Sheet1']
# Erstelle eine neue Excel-Tabelle für die sortierten Zeilen
output_workbook = openpyxl.Workbook()
output_sheet = output_workbook.active
# Kopiere den Header ins Ausgabe-Arbeitsblatt
copy_header(input_sheet, output_sheet)
# Lese die Daten-Zeilen aus der Tabelle
data_rows = list(input_sheet.iter_rows(min_row=2, values_only=True))
# Sortiere die Daten-Zeilen nach dem Wert der angegebenen Spalte
sorted_data_rows = sorted(data_rows, key=lambda x: x[18 - 1]) # -1, da Listenindizes bei 0 beginnen
# Schreibe die sortierten Daten-Zeilen in die neue Tabelle
for row in sorted_data_rows:
output_sheet.append(row)
# Speichere die Änderungen in der neuen Excel-Datei
output_workbook.save(output_file_path)
# Schließe die Excel-Dateien
input_workbook.close()
output_workbook.close()
#Sollten mehrere Testruns ausgewertet werden wollen, müssen die enthaltenen Funktionen umstrukturiert werden
#Aktuell wird nur der Testrun in Zeile 1 ausgewertet
#Eine Weitere Funktion, die zwei Tabellenzeilen tauscht, wäre der einfachste workaround
def evaluation(testcases, testruns):
#liest die Ergebnisse des Testruns aus
#bei mehreren Testruns muss diese Funktion angepasst werden!
input_string = excel_row_to_string(testruns)
#schreibt die Berechneten Ergebnisse in die Testcases-Tabelle
write_subdivided_string_to_excel(testcases, input_string)
#liest die gemessenen und die errechneten Werte aus den Testcases
values_col1, values_col2 = read_columns(testcases)
#berechnet aus diesen Werten die prozentuale Abweichung
deviations = calculate_deviation(values_col1, values_col2)
#Trägt die prozentualen Abweichungen in die Testcases-Tabelle
#je nach Tabellenstruktur kann sich die 18 ändern!
write_string_to_excel(testcases, deviations, 18)
#Gibt die eine Kopie der Testcases-Tabelle sortiert nach Genauigkeit aus
sort_excel(testcases, 'Testcases_nach_Genauigkeit.xlsx')

271
code/excel_processing.py
View File

@ -1,132 +1,139 @@
""" """
Abhängigkeiten: Abhängigkeiten:
- pyramids (für den Aufbau der Bildpyramiden) - pyramids (für den Aufbau der Bildpyramiden)
- heartrate (zur Berechnung der Herzfrequenz) - heartrate (zur Berechnung der Herzfrequenz)
- preprocessing (für die Video-Vorverarbeitung) - preprocessing (für die Video-Vorverarbeitung)
- eulerian (für die Euler'sche Video-Magnifikation) - eulerian (für die Euler'sche Video-Magnifikation)
- tkinter und constants (für die GUI und Konstantenverwaltung) - tkinter und constants (für die GUI und Konstantenverwaltung)
Autor: Roberto Gelsinger Autor: Roberto Gelsinger
Datum: 07.12.2023 Datum: 07.12.2023
Version: Modulversion Version: Modulversion
""" """
import pyramids import pyramids
import heartrate import heartrate
import facedetection import facedetection
import eulerian import eulerian
from constants import freq_max, freq_min from constants import freq_max, freq_min
import pandas as pd import pandas as pd
from excel_update import color_cells_based_on_deviation from excel_update import color_cells_based_on_deviation
from excel_evaluation import evaluation
def process_video_for_excel(selected_video_name):
""" def process_video_for_excel(selected_video_name):
Verarbeitet ein ausgewähltes Video, um die Herzfrequenz der abgebildeten Person zu ermitteln. """
Verarbeitet ein ausgewähltes Video, um die Herzfrequenz der abgebildeten Person zu ermitteln.
Dieser Prozess umfasst die Vorverarbeitung des Videos, den Aufbau einer Laplace-Pyramide,
die Anwendung von FFT-Filterung und Euler'scher Magnifikation, und schließlich die Berechnung Dieser Prozess umfasst die Vorverarbeitung des Videos, den Aufbau einer Laplace-Pyramide,
der Herzfrequenz aus den Video-Daten. die Anwendung von FFT-Filterung und Euler'scher Magnifikation, und schließlich die Berechnung
der Herzfrequenz aus den Video-Daten.
Args:
selected_video_name (str): Der Name des zu verarbeitenden Videos. Args:
selected_video_name (str): Der Name des zu verarbeitenden Videos.
Returns:
None: Die Funktion gibt direkt die berechnete Herzfrequenz auf der Konsole aus. Returns:
""" None: Die Funktion gibt direkt die berechnete Herzfrequenz auf der Konsole aus.
"""
print("Reading + preprocessing video...")
video_frames, frame_ct, fps = facedetection.read_video("videos/"+selected_video_name) print("Reading + preprocessing video...")
video_frames, frame_ct, fps = facedetection.read_video("videos/"+selected_video_name)
print("Building Laplacian video pyramid...") print(len(video_frames))
lap_video = pyramids.build_video_pyramid(video_frames)
print("Building Laplacian video pyramid...")
lap_video = pyramids.build_video_pyramid(video_frames)
for i, video in enumerate(lap_video): print(len(lap_video))
if i == 0 or i == len(lap_video)-1:
continue for i, video in enumerate(lap_video):
print("test")
print("Running FFT and Eulerian magnification...") if i == 0 or i == len(lap_video)-1:
result, fft, frequencies = eulerian.fft_filter(video, freq_min, freq_max, fps) continue
lap_video[i] += result
print("Running FFT and Eulerian magnification...")
result, fft, frequencies = eulerian.fft_filter(video, freq_min, freq_max, fps)
print("Calculating heart rate...") lap_video[i] += result
heart_rate = heartrate.find_heart_rate(fft, frequencies, freq_min, freq_max)
print("Calculating heart rate...")
heart_rate = heartrate.find_heart_rate(fft, frequencies, freq_min, freq_max)
print("Heart rate: ", heart_rate*0.7, "bpm")
return heart_rate *0.7
print("Heart rate: ", heart_rate*0.7, "bpm")
return heart_rate *0.7
def process_all_videos_and_save_results(testcase_excel_file_path, testruns_excel_file_path, code_version, kommentar):
try:
df_testruns = pd.read_excel(testruns_excel_file_path) def process_all_videos_and_save_results(testcase_excel_file_path, testruns_excel_file_path, code_version, kommentar):
except FileNotFoundError:
df_testruns = pd.DataFrame() try:
df_testruns = pd.read_excel(testruns_excel_file_path)
except FileNotFoundError:
df_testcases = pd.read_excel(testcase_excel_file_path) df_testruns = pd.DataFrame()
existing_testcases = [col for col in df_testruns.columns if col.startswith('Testcase_')]
df_testcases = pd.read_excel(testcase_excel_file_path)
new_testcases = [f'Testcase_{tc}' for tc in df_testcases['Testcase'] if f'Testcase_{tc}' not in existing_testcases]
existing_testcases = [col for col in df_testruns.columns if col.startswith('Testcase_')]
if df_testruns.empty: new_testcases = [f'Testcase_{tc}' for tc in df_testcases['Testcase'] if f'Testcase_{tc}' not in existing_testcases]
df_testruns = pd.DataFrame(columns=['Testnummer', 'Codeversion', 'Kommentar', 'Abweichung'])
if df_testruns.empty:
for col in new_testcases: df_testruns = pd.DataFrame(columns=['Testnummer', 'Codeversion', 'Kommentar', 'Abweichung'])
df_testruns[col] = None
for col in new_testcases:
df_testruns.to_excel(testruns_excel_file_path, index=False) df_testruns[col] = None
if new_testcases:
print(f"Folgende neue Testcases wurden hinzugefügt: {new_testcases}") df_testruns.to_excel(testruns_excel_file_path, index=False)
else:
print("Keine neuen Testcases zum Hinzufügen gefunden.") if new_testcases:
print(f"Folgende neue Testcases wurden hinzugefügt: {new_testcases}")
next_testcase_index = len(df_testruns) + 1 else:
print("Keine neuen Testcases zum Hinzufügen gefunden.")
new_run = { next_testcase_index = len(df_testruns) + 1
'Testnummer': next_testcase_index,
'Codeversion': code_version,
'Kommentar': kommentar, new_run = {
'Abweichung': 'Wert_für_Abweichung' 'Testnummer': next_testcase_index,
} 'Codeversion': code_version,
'Kommentar': kommentar,
'Abweichung': 'Wert_für_Abweichung'
for index, row in df_testcases.iterrows(): }
video_name = row['VideoName']
heart_rate = process_video_for_excel(video_name)
for index, row in df_testcases.iterrows():
video_name = row['VideoName']
testcase_column_name = f'Testcase_{row["Testcase"]}' heart_rate = process_video_for_excel(video_name)
new_run[testcase_column_name] = heart_rate
try: testcase_column_name = f'Testcase_{row["Testcase"]}'
new_run[testcase_column_name] = heart_rate
df_testruns = df_testruns._append(new_run, ignore_index=True)
except TypeError: try:
pass
df_testruns = df_testruns._append(new_run, ignore_index=True)
except TypeError:
df_testruns.to_excel(testruns_excel_file_path, index=False) pass
print("Testrun wurde verarbeitet und das Ergebnis in der Testruns-Excel-Datei gespeichert.")
df_testruns.to_excel(testruns_excel_file_path, index=False)
color_cells_based_on_deviation(testruns_excel_file_path, testcase_excel_file_path)
print("Testrun wurde verarbeitet und das Ergebnis in der Testruns-Excel-Datei gespeichert.")
print("Zellen gefärbt")
color_cells_based_on_deviation(testruns_excel_file_path, testcase_excel_file_path)
print("Zellen gefärbt")
evaluation(testcase_excel_file_path, testruns_excel_file_path)
print("Testcases sortiert")