First files for testing from WND

main.py

@@ -0,0 +1,245 @@
+import pandas as pd
+import dash
+from dash import dcc, html
+import webbrowser
+from src.viz import Visualizer as viz
+import plotly.graph_objects as go
+import os
+import datetime
+import plotly.express as px
+import json
+
+start_time = 0#240
+end_time = 1600#600
+
+start_date = datetime.datetime(2024, 6, 7, 12, 0, 0)
+end_date = start_date + datetime.timedelta(seconds=end_time)
+
+# Initialize the Dash app
+app = dash.Dash(__name__, suppress_callback_exceptions=True)
+
+# Global dictionary to store data
+data_store = {}
+
+def parse_action_trace(path, exclude = []):
+    """
+    Parses action data from CSV files into a dictionary.
+
+    This function reads CSV files specified in a dictionary where each key-value pair
+    corresponds to an condition ID and its associated file. It extracts columns related to
+    time, action name, agent name, action end time, and attributes from each file and
+    stores them in a nested dictionary structure.
+
+    Args:
+        files_dict (dict): A dictionary where keys are action IDs and values are file paths.
+
+    Returns:
+        dict: A dictionary where each key is an condition ID and the value is another dictionary
+              containing parsed data from the corresponding CSV file.
+    """
+
+    df = pd.read_csv(path, engine = "python")
+    
+    # Convert to events list for timeline plotting
+    events = []
+
+    for i in range(len(df['time'])):
+        if not any(excl in df['actionName'][i] for excl in exclude):
+            event = {
+                'agent': df['agentName'][i],
+                'name': df['actionName'][i],
+                'start': start_date + datetime.timedelta(seconds=df['time'][i]),
+                'end': start_date + datetime.timedelta(seconds=df['time'][i] + max(df['actionEndTime'][i], 2)),
+                'duration': max(df['actionEndTime'][i], 2),
+                'attributes': df['attributes'][i]
+            }
+            events.append(event)
+
+    return events
+
+def parse_all_data(path):
+
+    # Get the list of subfolders in the 'data' folder
+    subfolders = [f.name for f in os.scandir(path) if f.is_dir()]
+
+    # Load all data at the start of the program
+    # Load the CSV files into pandas DataFrames from the selected subfolder
+    data = {}
+    exclude = ['Detect_crash','Detect_conflict','Flight_Dynamics','Reroute_flight','Show_radar','Direct_to_waypoint','Change_heading','fly']
+    for subfolder in subfolders:
+        data[subfolder] = {
+            'wnd_action_trace': pd.read_csv(f'{path}/{subfolder}/actionTrace_Agent_PIC Blaze.csv'),
+            'all_action_trace': parse_action_trace(f'{path}/{subfolder}/actionTrace.csv', exclude),
+        }
+        data[subfolder]['aircraft_data'] = {}
+        for file in os.listdir(f'{path}/{subfolder}'):
+            if file.endswith('_acstate.csv'):
+                aircraft_id = file.split('_')[0]
+                data[subfolder]['aircraft_data'][aircraft_id] = pd.read_csv(f'{path}/{subfolder}/{file}')
+
+    subfolder_labels = [{'label': i, 'value': i} for i in subfolders]
+
+    return subfolder_labels, data
+
+# Create the layout for the app
+app.layout = html.Div([
+    html.Div([
+        html.Div("Input the relative path to your results folder, then click 'Submit':", id='text1'),
+        dcc.Input(
+            id='path-input',
+            # value='data',
+            type='text',
+            placeholder='Type your path... For example, ../wmc5.1/Scenario/AAMv2/Results',
+            style={'width': '90%'}  # Make the input wider
+        ),
+        html.Button('Submit', id='submit-button', n_clicks=0),
+        # Create a dropdown menu with the subfolders as options
+        html.Div("Once all subfolders are loaded (representing the different conditions you ran in WMC), you can select which one to plot:", id='text2'),
+        dcc.Dropdown(
+            id='subfolder-dropdown',
+            value=None #subfolders[0]  # Default value
+            )
+    ], style={'width': '50%', 'border': '1px solid gray'}),
+
+    html.Div([
+        html.Div([
+            dcc.Graph(id='map'),  # Second graph
+            dcc.Dropdown(
+                id='variable-dropdown',
+                # options=[{'label': i, 'value': i} for i in subfolders],
+                value=None #subfolders[0]  # Default value
+            ),
+            dcc.Graph(id='altitude-series') # Third graph
+        ], style={'width': '39%', 'display': 'inline-block', 'border': '1px solid gray'}),      
+        html.Div([
+            dcc.Tabs(id='tabs-example-1', value='tab-1', children=[
+                dcc.Tab(label='Traditional Action Trace', value='tab-1'),
+                dcc.Tab(label='What`s Next Diagram', value='tab-2'),
+            ]),
+            html.Div(id='tabs-example-content-1'),
+            html.Div([dcc.Graph(id='timeline')], id='tab-1-content', style={'display': 'none'}),  # Fourth graph
+            html.Div([dcc.Graph(id='time-series')], id='tab-2-content', style={'display': 'none'}),  # First graph
+        ], style={'width': '59%', 'display': 'inline-block', 'border': '1px solid gray'})
+    ], style={'display': 'flex'}),
+
+    html.Div(
+        dcc.Slider(
+            id='time-slider',
+            min=start_time,
+            max=end_time,
+            value=start_time+100,
+            marks={str(time): str(time) for time in range(start_time, end_time+1, 50)},
+            updatemode='drag'
+        ),
+        style={'width': '100%'}  # Set the width of the div containing the slider to 80% of the container
+    )
+
+])
+
+@app.callback(
+    dash.dependencies.Output('tab-1-content', 'style'),
+    dash.dependencies.Output('tab-2-content', 'style'),
+    dash.dependencies.Input('tabs-example-1', 'value')
+)
+def render_content(tab):
+    if tab == 'tab-1':
+        return {'display': 'block'}, {'display': 'none'}
+    elif tab == 'tab-2':
+        return {'display': 'none'}, {'display': 'block'}
+    
+# Load data when the app starts and store it in the hidden div
+@app.callback(
+    dash.dependencies.Output('subfolder-dropdown', 'options'),
+    dash.dependencies.Output('variable-dropdown', 'options'),
+    [dash.dependencies.Input('submit-button', 'n_clicks')],
+    [dash.dependencies.Input('path-input', 'value')],
+)
+def load_data(n_clicks, selected_path):
+    print("selected path is",selected_path)
+    global data_store
+    if n_clicks > 0:
+        if selected_path is None or not os.path.isdir(selected_path):
+            return [], []
+        subfolder_labels, data = parse_all_data(selected_path)
+        print('subfolders',subfolder_labels)
+        if data is None:
+            data = {}
+        # Store data in the global dictionary
+        data_store = data
+        labels = list(data[list(data.keys())[0]]['aircraft_data'][list(data[list(data.keys())[0]]['aircraft_data'].keys())[0]].columns.tolist())  # Extracting column names for the first aircraft-specific dataframe
+        return subfolder_labels, labels
+    else:
+        return [], []
+
+# Define the callback to update the graphs based on the slider value
+@app.callback(
+    dash.dependencies.Output('time-series', 'figure'),
+    dash.dependencies.Output('map', 'figure'),
+    dash.dependencies.Output('altitude-series', 'figure'),
+    dash.dependencies.Output('timeline', 'figure'),
+    #  dash.dependencies.Input('path-input', 'value'),
+    [dash.dependencies.Input('subfolder-dropdown', 'value'),
+     dash.dependencies.Input('time-slider', 'value'),
+     dash.dependencies.Input('variable-dropdown','value')]
+)
+# def update_graph(selected_subfolder, selected_time):
+#     # Load the CSV files into pandas DataFrames from the selected subfolder
+#     df1 = pd.read_csv(f'data/{selected_subfolder}/actionTrace_Agent_PIC Blaze.csv')
+#     df2 = pd.read_csv(f'data/{selected_subfolder}/SNLBlaze_acstate.csv')
+#     df3 = pd.read_csv(f'data/{selected_subfolder}/GCCRaven_acstate.csv')
+
+#     exclude = ['Detect_crash','Detect_conflict','Flight_Dynamics','Reroute_flight','Show_radar','Direct_to_waypoint','Change_heading']
+#     events = parse_action_trace(f'data/{selected_subfolder}/actionTrace.csv', exclude)
+
+def update_graph(selected_subfolder, selected_time, selected_variable):
+    
+    if selected_subfolder not in data_store:
+        return go.Figure(), go.Figure(), go.Figure(layout=dict(autosize=True, width=None, height=300)), go.Figure()
+
+    wnd_action_trace = data_store[selected_subfolder].get('wnd_action_trace', pd.DataFrame())
+    all_action_trace = data_store[selected_subfolder].get('all_action_trace', [])
+    aircraft_data = data_store[selected_subfolder].get('aircraft_data', {})
+
+    filtered_wnd_action_trace = wnd_action_trace[(wnd_action_trace['time'] >= start_time) & (wnd_action_trace['time'] <= selected_time)]
+    
+    filtered_all_action_trace = []
+    for event in all_action_trace:
+        if (event['start'] - start_date).total_seconds() <= selected_time:
+            event_copy = event.copy()  # Create a local copy of the event
+            if (event_copy['end'] - start_date).total_seconds() > selected_time:
+                event_copy['end'] = start_date + datetime.timedelta(seconds=selected_time)
+            filtered_all_action_trace.append(event_copy)
+
+    ac_data = {}
+    for aircraft_id, df in aircraft_data.items():
+        filtered_df = df[(df['time'] >= start_time) & (df['time'] <= selected_time)]
+        ac_data[aircraft_id] = filtered_df
+
+    fig1 = go.Figure(layout=dict(autosize=True, width=None, height=500))
+    fig1['layout']['uirevision'] = 'Hello world!'
+    fig1 = viz.plot_trajectory(fig1, ac_data)
+
+    fig2 = go.Figure(layout=dict(autosize=True, width=700, height=700))
+    fig2 = viz.wnd_visualization(fig2, filtered_wnd_action_trace, selected_time, start_time, end_time)
+    fig2['layout']['uirevision'] = 'Hello world!'
+
+    if selected_variable is not None:
+        fig3 = go.Figure(layout=dict(autosize=True, width=None, height=300))
+        for aircraft_id, df in ac_data.items():
+            fig3.add_trace(go.Scatter(x=df['time'], y=df[selected_variable], mode='lines', name=aircraft_id))
+        fig3.update_layout(xaxis_title='Real Time', yaxis_title=selected_variable, showlegend=True, xaxis=dict(range=[start_time, end_time]))#, yaxis=dict(range=[0, 1200])
+        fig3['layout']['uirevision'] = 'Hello world!'
+
+    else:
+        fig3 = go.Figure(layout=dict(autosize=True, width=None, height=300))
+    fig4 = go.Figure(layout=dict(autosize=True, width=None, height=700))
+    fig4 = viz.timeline(fig4, filtered_all_action_trace, selected_time, start_date, end_date)
+    fig4['layout']['uirevision'] = 'Hello world!'
+
+    return fig2, fig1, fig3, fig4
+    
+# Run the app
+if __name__ == '__main__':
+
+    webbrowser.open_new("http://127.0.0.1:8050/")
+    app.run_server(debug=True)

src/__init__.py

@@ -0,0 +1,3 @@
+''' This file makes the folder it is stored in into
+    a package.
+'''

src/viz.py

@@ -0,0 +1,226 @@
+import webbrowser
+import dash as dcc
+import dash as html
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+import networkx as nx
+import datetime
+
+class Visualizer:
+
+    def wnd_visualization(figure_handle, dataframe, current_time, start_time = 0, end_time = 10^6):
+            # Diagonal line y=x
+        figure_handle.add_trace(go.Scatter(x=[start_time, end_time], y=[start_time, end_time], mode='lines', line=dict(color='black', dash='dash')))
+
+        # Dotted lines from the point to axes
+        figure_handle.add_trace(go.Scatter(x=[current_time, current_time, start_time], y=[start_time, current_time, current_time], mode='lines', line=dict(color='black', dash='dot')))
+
+        for time, name in dataframe[['time', 'actionName']].values:
+            figure_handle.add_trace(go.Scatter(x=[time], y=[time], mode='markers', marker=dict(color='black', size=10)))
+
+        timestamps_and_ids_dict = {}
+
+        for index, row in dataframe.iterrows():
+            array_data = row['attributes']
+            if isinstance(array_data, str):
+                timestamp_id_triples = []
+                for pair in array_data.split(';'):
+                    triple = pair.split('|')
+                    triple.append("")
+                    timestamp_id_triples.append(triple)
+                for triple in timestamp_id_triples:
+                    if '(' in triple[1]:
+                        triple[1], triple[2] = triple[1].split('(')
+            else:
+                timestamp_id_triples = []
+            timestamp_id_triples.sort(key=lambda x: float(x[0][0]))
+
+            timestamp_id_dict = {float(triple[0]): str(triple[1]) for triple in timestamp_id_triples}
+            timestamps_and_ids_dict[row['time']] = timestamp_id_dict
+
+        timestamps_before_simulation_time = {timestamp: data for timestamp, data in timestamps_and_ids_dict.items() if timestamp <= current_time}
+        print(timestamps_before_simulation_time)
+        mental_model_over_time = {}
+
+        if timestamps_before_simulation_time:
+            for mm_time, array_timestamps_and_ids in timestamps_before_simulation_time.items():
+                for timestamp, value in array_timestamps_and_ids.items():
+                    if value in mental_model_over_time:
+                        # Value is already in the dictionary, append the timestamp to the existing list
+                        mental_model_over_time[value].append((mm_time, timestamp))
+                    else:
+                        # Value is not in the dictionary, create a new list with the timestamp
+                        mental_model_over_time[value] = [(mm_time, timestamp)]
+
+            # Get last update on mental model
+            previous_timestamp, array_timestamps_and_ids = max(timestamps_before_simulation_time.items(), key=lambda x: x[0])
+
+            # Assuming mental model does not change in between, load this as current mental model into dictionary
+            for timestamp, value in array_timestamps_and_ids.items():
+                if value in mental_model_over_time:
+                    # Value is already in the dictionary, append the timestamp to the existing list
+                    mental_model_over_time[value].append((current_time, timestamp))
+                else:
+                    # Value is not in the dictionary, create a new list with the timestamp
+                    mental_model_over_time[value] = [(current_time, timestamp)]
+
+                # Add text box with name of event
+                figure_handle.add_annotation(x=current_time, y=timestamp, text=value, showarrow=True, arrowhead=1, arrowcolor='black', arrowwidth=2)
+
+        for label, coordinates in mental_model_over_time.items():
+            for i in range(len(coordinates) - 1):
+                x = [coordinates[i][0], coordinates[i + 1][0], coordinates[i + 1][0]]
+                y = [coordinates[i][1], coordinates[i][1], coordinates[i + 1][1]]
+
+                if all(xi <= yi for xi, yi in zip(x, y)):
+                    figure_handle.add_trace(go.Scatter(x=x, y=y, mode='lines', line=dict(color='blue'), marker_symbol='triangle-up'))
+
+                if all(xi >= yi for xi, yi in zip(x, y)):
+                    figure_handle.add_trace(go.Scatter(x=x, y=y, mode='lines', line=dict(color='gray'), marker_symbol='circle'))
+
+        figure_handle.update_layout(
+            xaxis_title='Real Time',
+            yaxis_title='Comprehension of Timeline of Events',
+            showlegend=False,
+            xaxis=dict(
+                range=[start_time,end_time]
+            ),
+            yaxis=dict(
+                range=[start_time,end_time],
+                scaleanchor="x",
+                scaleratio=1
+            )
+        )
+
+        return figure_handle
+
+    def plot_trajectory(figure_handle, parsed_data, uptime=float('inf'), background_image=None):
+        fig = figure_handle
+
+        if background_image:
+            fig.add_layout_image(
+                source=background_image,
+                xref="x",
+                yref="y",
+                x=-96.88,
+                y=33.16,
+                sizex=0.23,
+                sizey=0.44,
+                sizing="fill",
+                opacity=0.5,
+                layer="below"
+            )
+        else:
+            fig.update_layout(
+                mapbox_style="open-street-map",
+                mapbox_center_lon=-96.765,
+                mapbox_center_lat=32.95,
+                mapbox_zoom=10
+            )
+
+        # Create a graph for the flight plans
+        G = nx.Graph()
+
+        # Define waypoints and their positions with new names from the embedded code
+        waypoints = {
+            "NTI": (-96.7535, 32.928), "NTHW": (-96.749, 32.8573), "RUBL": (-96.7588, 32.78), 
+            "HW342": (-96.8003, 32.7508), "TLWY": (-96.807, 32.769), "4DT": (-96.8508, 32.846),
+            "T57": (-96.686, 32.888), "FSC": (-96.8213, 33.1413), "PLN": (-96.7275, 33.0297)
+        }
+
+        # Add edges between waypoints to the graph with updated names
+        edges = [("NTI", "NTHW"), ("NTHW", "RUBL"), ("RUBL", "HW342"), ("HW342", "TLWY"), 
+                 ("TLWY", "4DT"), ("T57", "NTI"), ("FSC", "PLN"),("PLN","NTI")]
+        G.add_edges_from(edges)
+
+        # Draw the graph with smaller waypoint symbols in gray and keep the node labels
+        for edge in G.edges():
+            x_values = [waypoints[edge[0]][0], waypoints[edge[1]][0]]
+            y_values = [waypoints[edge[0]][1], waypoints[edge[1]][1]]
+            fig.add_trace(go.Scattermapbox(lon=x_values, lat=y_values, mode='lines', line=dict(color='gray'), showlegend=False))#, dash='dash'
+
+        for node in G.nodes():
+            x_value = waypoints[node][0]
+            y_value = waypoints[node][1]
+            fig.add_trace(go.Scattermapbox(lon=[x_value], lat=[y_value], mode='markers', marker=dict(size=5, color='gray'), showlegend=False))#, symbol='pentagon'
+        # for node, (x_value, y_value) in waypoints.items():
+            # fig.add_annotation(lon=x_value, lat=y_value, text=node, showarrow=False, font=dict(size=6, color='gray'), xanchor='left', yanchor='bottom')
+            
+        # Add legend label for waypoints and corridors
+        legend_labels = []
+        legend_labels.append("Corridors")
+        legend_labels.append("Waypoints")
+
+        colors = ['blue', 'red', 'green', 'purple', 'orange', 'yellow', 'pink', 'cyan', 'magenta', 'brown']
+        color_index = 0
+
+        for ac_name, data in parsed_data.items():
+            mask = (data['time'] >= 0) & (data['time'] <= uptime)
+            filtered_xdata = data['longitude_deg'][mask]
+            filtered_ydata = data['latitude_deg'][mask]
+            filtered_heading = data['heading_deg'][mask]
+            filtered_altitude = data['altitude_ft'][mask] # In case we ever want to do 3D visualizations
+
+            fig.add_trace(go.Scattermapbox(#Scatter3d possibly for 3D but issue with Scattermapbox not being compatible
+                mode="lines",
+                lon=filtered_xdata,
+                lat=filtered_ydata,
+                line=dict(width=2, color=colors[color_index]),
+                name=ac_name
+            ))
+
+            if len(filtered_xdata) > 0 and len(filtered_ydata) > 0:
+                current_heading = filtered_heading.iloc[-1]
+                fig.add_trace(go.Scattermapbox(
+                    mode="markers",
+                    lon=[filtered_xdata.iloc[-1]],
+                    lat=[filtered_ydata.iloc[-1]],
+                    marker=dict(size=10, color=colors[color_index]),#, symbol=['cross']), #To make custom markers, you need MapBox access token (to use any of Mapbox's tools, APIs, or SDK)
+                    name=ac_name + " Current Location"
+                ))
+
+            color_index = (color_index + 1) % len(colors)
+
+        fig.update_layout(
+            mapbox=dict(
+                center=dict(lon=-96.765, lat=32.95),
+                zoom=9
+            ),
+            margin=dict(l=20, r=20, t=20, b=20)
+        )
+
+        return fig
+
+    def timeline(figure_handle, events, current_time = 0, start_date = 0, end_date = 0):
+
+        category_order = sorted(list(set([e['agent'] for e in events])))
+        
+        figure_handle = px.timeline(
+            events, x_start="start", x_end="end", y="agent", 
+            hover_data=['attributes', 'duration'], 
+            color='name',# height=400, width=1600, 
+            category_orders={'agent': category_order}
+        )
+
+        # Add a vertical dashed line at x = current_time
+        current_datetime = start_date + datetime.timedelta(seconds=current_time)
+        figure_handle.add_shape(
+            type="line",
+            x0=current_datetime, y0=0,
+            x1=current_datetime, y1=1,
+            yref="paper",
+            line=dict(
+                color="Black",
+                width=2,
+                dash="dash",
+            )
+        )
+
+        figure_handle.update_layout(
+            xaxis_range=[start_date, end_date]#,
+            # width=600, 
+            # height=500
+        )
+
+        return figure_handle