reanming fronent filter

DataModel.py

@@ -35,8 +35,7 @@ class DataModel:
             st.error('Error while data loading')
             st.stop()
         # extrect feature variables from returned request json
-        directs, feature, kpis, gdf = _self.__extract_backend_data(response)
-        return directs, feature, kpis, gdf
+        return _self.__extract_backend_data(response)
     
     def __waiting_for_calculation(self, node_id, extension_radius):
         """
@@ -67,8 +66,7 @@ class DataModel:
         :return req: response data from endpoint
         """
         url = self.base_url + f'/task_status/{node_id}/{extension_radius}/NodeTimeLoss'
-        req = requests.get(url, headers={'X-API-KEY':st.secrets['api_key']})
-        return req
+        return requests.get(url, headers={'X-API-KEY':st.secrets['api_key']})
 
     def __extract_backend_data(self, response):
         """
@@ -93,8 +91,6 @@ class DataModel:
                    'Standing2LossRatio':pd.read_json(json_data['feature']['Standing2LossRatio']),
                    'TimeLoss':pd.read_json(json_data['feature']['TimeLoss']),
                    'StandingTime':pd.read_json(json_data['feature']['StandingTime'])}
-        # extract and process rush hour feature saved in a dataframe with traveling directions
-        #time = json_data['time']
         # extract main KPIs of the node for displaying in the dashboard
         kpis = json_data['kpis']
         # extract GeoDataFrame with node geometry and extended node geometry

Visualization.py

@@ -4,7 +4,6 @@ import streamlit as st
 import numpy as np
 import pandas as pd
 import matplotlib as mpl
-import ast
 import bezier
 
 class Visualization:
@@ -25,12 +24,16 @@ class Visualization:
         
     def get_final_result(self, timeloss):
         """
+        Function for calculating the time loss class in a range from
+        'A' very good to 'F' very bad
+        :param timeloss: worst relevant timeloss of node driving directions
+        :return: timeloss class
         """
         final = -1
         for idx in  range(1, len(self.bounds)):
             if self.bounds[idx-1] < timeloss <=self.bounds[idx]:
-                final = idx-1
-                break
+                return self.final_result[idx-1]
+                
         return self.final_result[final]
     
     def create_folium_map(self, gdf):
@@ -65,6 +68,11 @@ class Visualization:
         return figures, results, min_loss
 
     def get_min_relavent_direction_loss(self, results):
+        """
+        Method for calculating the timeloss of the worst relevant node path
+        :param results: dataframe with possible driving paths and timelosses
+        :return: timeloss
+        """
         total_rides = sum([df[df['Richtung']=='Gesamt']['Fahrten'].sum() for df in results])
         min_rides = self.min_ride_percentage*total_rides
         loss_class = []
@@ -89,15 +97,14 @@ class Visualization:
         :param df_time: datafrme with the aggregated rushhour feature of the travel direction
         """
         # initialise dataframes for displaying feature in dataframe format
-        df_result = pd.DataFrame(index=range(len(directs)+1),columns=['Richtung', 'Wartezeit', 'Zeitverlust', 'Ratio', 'Fahrten'])
+        df_result = pd.DataFrame(index=range(len(directs)+1),columns=['Richtung', 'Standzeit', 'Zeitverlust', 'Ratio', 'Fahrten'])
         # define maplotlib figure and axes objects for direction plots
         fig_loss, axs_loss = plt.subplots(1,3, figsize=(8,4), gridspec_kw={'width_ratios':[1, 1, 0.15]})
         # setup input angle and transform data into the radians and the projection onto the unit circle
         angle_in = directs[current_key]['value']
         origin = (180+angle_in)%360
         rad_origin = np.deg2rad(origin)
-        x_origin = np.cos(rad_origin) 
-        y_origin = np.sin(rad_origin)
+        x_origin, y_origin = np.cos(rad_origin), np.sin(rad_origin)
         # initialise tracking parameter for total time quality feature estimation of the travel directions
         total_loss = 0
         total_rides = 0
@@ -120,7 +127,7 @@ class Visualization:
             # save aggregated time quality data in dataframe
             df_result.at[i, 'Richtung'] = f"{directs[dkey_out]['name']}"
             df_result.at[i, 'Zeitverlust'] = np.round(timeloss,2)
-            df_result.at[i, 'Wartezeit'] = np.round(waiting,2)
+            df_result.at[i, 'Standzeit'] = np.round(waiting,2)
             df_result.at[i, 'Fahrten'] = rides
             df_result.at[i, 'Ratio'] = np.round(ratio,2)
             total_loss += rides*timeloss
@@ -171,7 +178,7 @@ class Visualization:
             axs_loss[a].axis('off')
         # set plot titles
         axs_loss[0].set_title(f'Zeitverlust')
-        axs_loss[1].set_title(f'Wartezeit')
+        axs_loss[1].set_title(f'Standzeit')
         # drop not used columns from dataframe
         df_result.dropna(inplace=True)
         # calculate mean resulting feature of all directions for time quality feature
@@ -179,7 +186,7 @@ class Visualization:
         df_result.at[i+1, 'Fahrten'] = total_rides
         if total_rides >0:
             df_result.at[i+1, 'Zeitverlust'] = np.round(total_loss/total_rides, 2)
-            df_result.at[i+1, 'Wartezeit'] = np.round(total_waiting/total_rides, 2)
+            df_result.at[i+1, 'Standzeit'] = np.round(total_waiting/total_rides, 2)
             df_result.at[i+1, 'Ratio'] = np.round(total_ratio/total_rides, 2)
         else:
             df_result.fillna(0, inplace=True)
@@ -207,9 +214,7 @@ class Visualization:
             data.append(curve.evaluate(float(p)))
         # reshape data
         data = np.array(data).reshape(n,2)
-        x_out = data[:,0] 
-        y_out = data[:,1]
-        return x_out, y_out
+        return data[:,0], data[:,1]
 
     def get_unit_circle_data(self, n=50):
         """
@@ -218,10 +223,9 @@ class Visualization:
         :return x: x coordinates of the points on the unit circle
         :return y: y coordinates of the poits on the unit cirlce
         """
-        alpha = np.linspace(0, np.pi*2,n, endpoint=True)
-        x = np.cos(alpha)
-        y = np.sin(alpha)
-        return x,y
+        alpha = np.linspace(0, 2*np.pi, n, endpoint=True)
+        # return x and y coordinates in polor coordinate system with radius = 1
+        return np.cos(alpha), np.sin(alpha)
 
     def get_metric_color(self, value):
         """

app.py

@@ -1,5 +1,4 @@
 import streamlit as st
-import numpy as np
 from streamlit_folium import st_folium
 from DataModel import DataModel
 from Visualization import Visualization
@@ -7,8 +6,6 @@ from Visualization import Visualization
 def app_run(node_id=0):
     # page configs
     st.set_page_config(page_title='Zeitverluste an Knotenpunkten', layout='wide')
-    #st.write(st.__version__)
-    
     # handle empty query parameter
     node = st.experimental_get_query_params()
     if 'node_id' in node:
@@ -26,7 +23,7 @@ def app_run(node_id=0):
     st.session_state['extension_radius'] = 30#[m]
     
     # get data from backend
-    directs, feature, kpis, gdf = dm.get_data_of_node(st.session_state['node_id'],st.session_state['extension_radius'])
+    directs, feature, _, gdf = dm.get_data_of_node(st.session_state['node_id'],st.session_state['extension_radius'])
     # create images for direction and 
     with st.spinner('Grafiken werden erstellt ...'):
         folium_map = visu.create_folium_map(gdf)
@@ -34,7 +31,7 @@ def app_run(node_id=0):
 
     usable_rides = int(sum([df.tail(1)['Fahrten'] for df in results]))
     mean_time_loss = float(sum([df.tail(1)['Fahrten']*df.tail(1)['Zeitverlust'] for df in results])/usable_rides)
-    mean_waiting_time = float(sum([df.tail(1)['Fahrten']*df.tail(1)['Wartezeit'] for df in results])/usable_rides)
+    mean_waiting_time = float(sum([df.tail(1)['Fahrten']*df.tail(1)['Standzeit'] for df in results])/usable_rides)
     # dsipaly time quality plots, time quality dataframes and rush hour data frames for each travel direction in a different tab
     input_directions = [f"Richtung {directs[d]['name']}" for d in directs]
     #
@@ -48,7 +45,7 @@ def app_run(node_id=0):
     elem1.header(f":{color}[{visu.float2str(mean_time_loss)}s]")
     #
     elem2 = metric_cols[2].container()#border=True
-    elem2.markdown('Gesamte Wartezeit')
+    elem2.markdown('Gesamte Standzeit')
     color = visu.get_metric_color(mean_waiting_time)
     elem2.header(f":{color}[{visu.float2str(mean_waiting_time)}s]")
     #
@@ -56,7 +53,7 @@ def app_run(node_id=0):
     elem3.markdown('Gesamtbewertung')
     color = visu.get_metric_color(worst_relevant_loss['Zeitverlust'])
     final_class = visu.get_final_result(worst_relevant_loss['Zeitverlust'])
-    indirection =input_directions[worst_relevant_loss['InDirection']]
+    indirection = input_directions[worst_relevant_loss['InDirection']]
     elem3.header(f":{color}[{final_class}, {visu.float2str(worst_relevant_loss['Zeitverlust'])}s]")
     elem3.text(f" Einfahrtsrichtung: {indirection[9:]} \n Ausfahrtsrichtung: {worst_relevant_loss['Richtung']}")
     # define column layout
@@ -76,12 +73,12 @@ def app_run(node_id=0):
     cols[0].dataframe(results[idx], hide_index=True, use_container_width=True)
         
 def get_plot_helper_text():
-    return '''Darstellung der Warte- und Verlustzeiten an den Ein- und Ausfahrtswegen im Knotenpunkt. 
+    return '''Darstellung der Stand- und Verlustzeiten an den Ein- und Ausfahrtswegen im Knotenpunkt. 
             Zeitliche Verluste werden entsprechend den Qualitätsklassen farblich visualisiert. 
             Zusätzlich erfolgt die Darstellung der Anzahl der Fahrten pro Fahrtrichtung durch die Breite der Linien. '''
     
 def get_table_helper_text():
-    return '''Liste der durchschnittlichen Warte- und Verlustzeiten pro Fahrtrichtung, 
+    return '''Liste der durchschnittlichen Stand- und Verlustzeiten pro Fahrtrichtung, 
             wobei die Richtungen den in der Abbildung dargestellten Fahrtrichtungen entsprechen.'''
 
 if __name__ == '__main__':