371 lines
15 KiB
Python
Executable File
371 lines
15 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import argparse
|
|
import os
|
|
import pyautogui
|
|
import subprocess
|
|
import dearpygui.dearpygui as dpg
|
|
import multiprocessing
|
|
import uuid
|
|
import signal
|
|
import yaml # type: ignore
|
|
from openpilot.common.swaglog import cloudlog
|
|
from openpilot.common.basedir import BASEDIR
|
|
from openpilot.tools.jotpluggler.data import DataManager
|
|
from openpilot.tools.jotpluggler.datatree import DataTree
|
|
from openpilot.tools.jotpluggler.layout import LayoutManager
|
|
|
|
DEMO_ROUTE = "a2a0ccea32023010|2023-07-27--13-01-19"
|
|
|
|
|
|
class WorkerManager:
|
|
def __init__(self, max_workers=None):
|
|
self.pool = multiprocessing.Pool(max_workers or min(4, multiprocessing.cpu_count()), initializer=WorkerManager.worker_initializer)
|
|
self.active_tasks = {}
|
|
|
|
def submit_task(self, func, args_list, callback=None, task_id=None):
|
|
task_id = task_id or str(uuid.uuid4())
|
|
|
|
if task_id in self.active_tasks:
|
|
try:
|
|
self.active_tasks[task_id].terminate()
|
|
except Exception:
|
|
pass
|
|
|
|
def handle_success(result):
|
|
self.active_tasks.pop(task_id, None)
|
|
if callback:
|
|
try:
|
|
callback(result)
|
|
except Exception as e:
|
|
print(f"Callback for task {task_id} failed: {e}")
|
|
|
|
def handle_error(error):
|
|
self.active_tasks.pop(task_id, None)
|
|
print(f"Task {task_id} failed: {error}")
|
|
|
|
async_result = self.pool.starmap_async(func, args_list, callback=handle_success, error_callback=handle_error)
|
|
self.active_tasks[task_id] = async_result
|
|
return task_id
|
|
|
|
@staticmethod
|
|
def worker_initializer():
|
|
signal.signal(signal.SIGINT, signal.SIG_IGN)
|
|
|
|
def shutdown(self):
|
|
for task in self.active_tasks.values():
|
|
try:
|
|
task.terminate()
|
|
except Exception:
|
|
pass
|
|
self.pool.terminate()
|
|
self.pool.join()
|
|
|
|
|
|
class PlaybackManager:
|
|
def __init__(self):
|
|
self.is_playing = False
|
|
self.current_time_s = 0.0
|
|
self.duration_s = 0.0
|
|
self.num_segments = 0
|
|
|
|
self.x_axis_bounds = (0.0, 0.0) # (min_time, max_time)
|
|
self.x_axis_observers = [] # callbacks for x-axis changes
|
|
self._updating_x_axis = False
|
|
|
|
def set_route_duration(self, duration: float):
|
|
self.duration_s = duration
|
|
self.seek(min(self.current_time_s, duration))
|
|
|
|
def toggle_play_pause(self):
|
|
if not self.is_playing and self.current_time_s >= self.duration_s:
|
|
self.seek(0.0)
|
|
self.is_playing = not self.is_playing
|
|
texture_tag = "pause_texture" if self.is_playing else "play_texture"
|
|
dpg.configure_item("play_pause_button", texture_tag=texture_tag)
|
|
|
|
def seek(self, time_s: float):
|
|
self.current_time_s = max(0.0, min(time_s, self.duration_s))
|
|
|
|
def update_time(self, delta_t: float):
|
|
if self.is_playing:
|
|
self.current_time_s = min(self.current_time_s + delta_t, self.duration_s)
|
|
if self.current_time_s >= self.duration_s:
|
|
self.is_playing = False
|
|
dpg.configure_item("play_pause_button", texture_tag="play_texture")
|
|
return self.current_time_s
|
|
|
|
def set_x_axis_bounds(self, min_time: float, max_time: float, source_panel=None):
|
|
if self._updating_x_axis:
|
|
return
|
|
|
|
new_bounds = (min_time, max_time)
|
|
if new_bounds == self.x_axis_bounds:
|
|
return
|
|
|
|
self.x_axis_bounds = new_bounds
|
|
self._updating_x_axis = True # prevent recursive updates
|
|
|
|
try:
|
|
for callback in self.x_axis_observers:
|
|
try:
|
|
callback(min_time, max_time, source_panel)
|
|
except Exception as e:
|
|
print(f"Error in x-axis sync callback: {e}")
|
|
finally:
|
|
self._updating_x_axis = False
|
|
|
|
def add_x_axis_observer(self, callback):
|
|
if callback not in self.x_axis_observers:
|
|
self.x_axis_observers.append(callback)
|
|
|
|
def remove_x_axis_observer(self, callback):
|
|
if callback in self.x_axis_observers:
|
|
self.x_axis_observers.remove(callback)
|
|
|
|
class MainController:
|
|
def __init__(self, scale: float = 1.0):
|
|
self.scale = scale
|
|
self.data_manager = DataManager()
|
|
self.playback_manager = PlaybackManager()
|
|
self.worker_manager = WorkerManager()
|
|
self._create_global_themes()
|
|
self.data_tree = DataTree(self.data_manager, self.playback_manager)
|
|
self.layout_manager = LayoutManager(self.data_manager, self.playback_manager, self.worker_manager, scale=self.scale)
|
|
self.data_manager.add_observer(self.on_data_loaded)
|
|
self._total_segments = 0
|
|
|
|
def _create_global_themes(self):
|
|
with dpg.theme(tag="line_theme"):
|
|
with dpg.theme_component(dpg.mvLineSeries):
|
|
scaled_thickness = max(1.0, self.scale)
|
|
dpg.add_theme_style(dpg.mvPlotStyleVar_LineWeight, scaled_thickness, category=dpg.mvThemeCat_Plots)
|
|
|
|
with dpg.theme(tag="timeline_theme"):
|
|
with dpg.theme_component(dpg.mvInfLineSeries):
|
|
scaled_thickness = max(1.0, self.scale)
|
|
dpg.add_theme_style(dpg.mvPlotStyleVar_LineWeight, scaled_thickness, category=dpg.mvThemeCat_Plots)
|
|
dpg.add_theme_color(dpg.mvPlotCol_Line, (255, 0, 0, 128), category=dpg.mvThemeCat_Plots)
|
|
|
|
for tag, color in (("active_tab_theme", (37, 37, 38, 255)), ("inactive_tab_theme", (70, 70, 75, 255))):
|
|
with dpg.theme(tag=tag):
|
|
for cmp, target in ((dpg.mvChildWindow, dpg.mvThemeCol_ChildBg), (dpg.mvInputText, dpg.mvThemeCol_FrameBg), (dpg.mvImageButton, dpg.mvThemeCol_Button)):
|
|
with dpg.theme_component(cmp):
|
|
dpg.add_theme_color(target, color)
|
|
|
|
with dpg.theme(tag="tab_bar_theme"):
|
|
with dpg.theme_component(dpg.mvChildWindow):
|
|
dpg.add_theme_color(dpg.mvThemeCol_ChildBg, (51, 51, 55, 255))
|
|
|
|
def on_data_loaded(self, data: dict):
|
|
duration = data.get('duration', 0.0)
|
|
self.playback_manager.set_route_duration(duration)
|
|
|
|
if data.get('metadata_loaded'):
|
|
self.playback_manager.num_segments = data.get('total_segments', 0)
|
|
self._total_segments = data.get('total_segments', 0)
|
|
dpg.set_value("load_status", f"Loading... 0/{self._total_segments} segments processed")
|
|
elif data.get('reset'):
|
|
self.playback_manager.current_time_s = 0.0
|
|
self.playback_manager.duration_s = 0.0
|
|
self.playback_manager.is_playing = False
|
|
self._total_segments = 0
|
|
dpg.set_value("load_status", "Loading...")
|
|
dpg.set_value("timeline_slider", 0.0)
|
|
dpg.configure_item("timeline_slider", max_value=0.0)
|
|
dpg.configure_item("play_pause_button", texture_tag="play_texture")
|
|
dpg.configure_item("load_button", enabled=True)
|
|
elif data.get('loading_complete'):
|
|
num_paths = len(self.data_manager.get_all_paths())
|
|
dpg.set_value("load_status", f"Loaded {num_paths} data paths")
|
|
dpg.configure_item("load_button", enabled=True)
|
|
elif data.get('segment_added'):
|
|
segment_count = data.get('segment_count', 0)
|
|
dpg.set_value("load_status", f"Loading... {segment_count}/{self._total_segments} segments processed")
|
|
|
|
dpg.configure_item("timeline_slider", max_value=duration)
|
|
|
|
def save_layout_to_yaml(self, filepath: str):
|
|
layout_dict = self.layout_manager.to_dict()
|
|
with open(filepath, 'w') as f:
|
|
yaml.dump(layout_dict, f, default_flow_style=False, sort_keys=False)
|
|
|
|
def load_layout_from_yaml(self, filepath: str):
|
|
with open(filepath) as f:
|
|
layout_dict = yaml.safe_load(f)
|
|
self.layout_manager.clear_and_load_from_dict(layout_dict)
|
|
self.layout_manager.create_ui("main_plot_area")
|
|
|
|
def save_layout_dialog(self):
|
|
if dpg.does_item_exist("save_layout_dialog"):
|
|
dpg.delete_item("save_layout_dialog")
|
|
with dpg.file_dialog(
|
|
callback=self._save_layout_callback, tag="save_layout_dialog", width=int(700 * self.scale), height=int(400 * self.scale),
|
|
default_filename="layout", default_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "layouts")
|
|
):
|
|
dpg.add_file_extension(".yaml")
|
|
|
|
def load_layout_dialog(self):
|
|
if dpg.does_item_exist("load_layout_dialog"):
|
|
dpg.delete_item("load_layout_dialog")
|
|
with dpg.file_dialog(
|
|
callback=self._load_layout_callback, tag="load_layout_dialog", width=int(700 * self.scale), height=int(400 * self.scale),
|
|
default_path=os.path.join(os.path.dirname(os.path.realpath(__file__)), "layouts")
|
|
):
|
|
dpg.add_file_extension(".yaml")
|
|
|
|
def _save_layout_callback(self, sender, app_data):
|
|
filepath = app_data['file_path_name']
|
|
try:
|
|
self.save_layout_to_yaml(filepath)
|
|
dpg.set_value("load_status", f"Layout saved to {os.path.basename(filepath)}")
|
|
except Exception:
|
|
dpg.set_value("load_status", "Error saving layout")
|
|
cloudlog.exception(f"Error saving layout to {filepath}")
|
|
dpg.delete_item("save_layout_dialog")
|
|
|
|
def _load_layout_callback(self, sender, app_data):
|
|
filepath = app_data['file_path_name']
|
|
try:
|
|
self.load_layout_from_yaml(filepath)
|
|
dpg.set_value("load_status", f"Layout loaded from {os.path.basename(filepath)}")
|
|
except Exception:
|
|
dpg.set_value("load_status", "Error loading layout")
|
|
cloudlog.exception(f"Error loading layout from {filepath}:")
|
|
dpg.delete_item("load_layout_dialog")
|
|
|
|
def setup_ui(self):
|
|
with dpg.texture_registry():
|
|
script_dir = os.path.dirname(os.path.realpath(__file__))
|
|
for image in ["play", "pause", "x", "split_h", "split_v", "plus"]:
|
|
texture = dpg.load_image(os.path.join(script_dir, "assets", f"{image}.png"))
|
|
dpg.add_static_texture(width=texture[0], height=texture[1], default_value=texture[3], tag=f"{image}_texture")
|
|
|
|
with dpg.window(tag="Primary Window"):
|
|
with dpg.group(horizontal=True):
|
|
# Left panel - Data tree
|
|
with dpg.child_window(label="Sidebar", width=int(300 * self.scale), tag="sidebar_window", border=True, resizable_x=True):
|
|
with dpg.group(horizontal=True):
|
|
dpg.add_input_text(tag="route_input", width=int(-75 * self.scale), hint="Enter route name...")
|
|
dpg.add_button(label="Load", callback=self.load_route, tag="load_button", width=-1)
|
|
dpg.add_text("Ready to load route", tag="load_status")
|
|
dpg.add_separator()
|
|
|
|
with dpg.table(header_row=False, policy=dpg.mvTable_SizingStretchProp):
|
|
dpg.add_table_column(init_width_or_weight=0.5)
|
|
dpg.add_table_column(init_width_or_weight=0.5)
|
|
with dpg.table_row():
|
|
dpg.add_button(label="Save Layout", callback=self.save_layout_dialog, width=-1)
|
|
dpg.add_button(label="Load Layout", callback=self.load_layout_dialog, width=-1)
|
|
dpg.add_separator()
|
|
|
|
self.data_tree.create_ui("sidebar_window")
|
|
|
|
# Right panel - Plots and timeline
|
|
with dpg.group(tag="right_panel"):
|
|
with dpg.child_window(label="Plot Window", border=True, height=int(-(32 + 13 * self.scale)), tag="main_plot_area"):
|
|
self.layout_manager.create_ui("main_plot_area")
|
|
|
|
with dpg.child_window(label="Timeline", border=True):
|
|
with dpg.table(header_row=False):
|
|
btn_size = int(13 * self.scale)
|
|
dpg.add_table_column(width_fixed=True, init_width_or_weight=(btn_size + 8)) # Play button
|
|
dpg.add_table_column(width_stretch=True) # Timeline slider
|
|
dpg.add_table_column(width_fixed=True, init_width_or_weight=int(50 * self.scale)) # FPS counter
|
|
with dpg.table_row():
|
|
dpg.add_image_button(texture_tag="play_texture", tag="play_pause_button", callback=self.toggle_play_pause, width=btn_size, height=btn_size)
|
|
dpg.add_slider_float(tag="timeline_slider", default_value=0.0, label="", width=-1, callback=self.timeline_drag)
|
|
dpg.add_text("", tag="fps_counter")
|
|
with dpg.item_handler_registry(tag="plot_resize_handler"):
|
|
dpg.add_item_resize_handler(callback=self.on_plot_resize)
|
|
dpg.bind_item_handler_registry("right_panel", "plot_resize_handler")
|
|
|
|
dpg.set_primary_window("Primary Window", True)
|
|
|
|
def on_plot_resize(self, sender, app_data, user_data):
|
|
self.layout_manager.on_viewport_resize()
|
|
|
|
def load_route(self):
|
|
route_name = dpg.get_value("route_input").strip()
|
|
if route_name:
|
|
dpg.set_value("load_status", "Loading route...")
|
|
dpg.configure_item("load_button", enabled=False)
|
|
self.data_manager.load_route(route_name)
|
|
|
|
def toggle_play_pause(self, sender):
|
|
self.playback_manager.toggle_play_pause()
|
|
|
|
def timeline_drag(self, sender, app_data):
|
|
self.playback_manager.seek(app_data)
|
|
|
|
def update_frame(self, font):
|
|
self.data_tree.update_frame(font)
|
|
|
|
new_time = self.playback_manager.update_time(dpg.get_delta_time())
|
|
if not dpg.is_item_active("timeline_slider"):
|
|
dpg.set_value("timeline_slider", new_time)
|
|
|
|
self.layout_manager.update_all_panels()
|
|
|
|
dpg.set_value("fps_counter", f"{dpg.get_frame_rate():.1f} FPS")
|
|
|
|
def shutdown(self):
|
|
self.worker_manager.shutdown()
|
|
|
|
|
|
def main(route_to_load=None, layout_to_load=None):
|
|
dpg.create_context()
|
|
|
|
# TODO: find better way of calculating display scaling
|
|
try:
|
|
w, h = next(tuple(map(int, l.split()[0].split('x'))) for l in subprocess.check_output(['xrandr']).decode().split('\n') if '*' in l) # actual resolution
|
|
scale = pyautogui.size()[0] / w # scaled resolution
|
|
except Exception:
|
|
scale = 1
|
|
|
|
with dpg.font_registry():
|
|
default_font = dpg.add_font(os.path.join(BASEDIR, "selfdrive/assets/fonts/JetBrainsMono-Medium.ttf"), int(13 * scale * 2)) # 2x then scale for hidpi
|
|
dpg.bind_font(default_font)
|
|
dpg.set_global_font_scale(0.5)
|
|
|
|
viewport_width, viewport_height = int(1200 * scale), int(800 * scale)
|
|
mouse_x, mouse_y = pyautogui.position() # TODO: find better way of creating the window where the user is (default dpg behavior annoying on multiple displays)
|
|
dpg.create_viewport(
|
|
title='JotPluggler', width=viewport_width, height=viewport_height, x_pos=mouse_x - viewport_width // 2, y_pos=mouse_y - viewport_height // 2
|
|
)
|
|
dpg.setup_dearpygui()
|
|
|
|
controller = MainController(scale=scale)
|
|
controller.setup_ui()
|
|
|
|
if layout_to_load:
|
|
try:
|
|
controller.load_layout_from_yaml(layout_to_load)
|
|
print(f"Loaded layout from {layout_to_load}")
|
|
except Exception as e:
|
|
print(f"Failed to load layout from {layout_to_load}: {e}")
|
|
cloudlog.exception(f"Error loading layout from {layout_to_load}")
|
|
|
|
if route_to_load:
|
|
dpg.set_value("route_input", route_to_load)
|
|
controller.load_route()
|
|
|
|
dpg.show_viewport()
|
|
|
|
# Main loop
|
|
try:
|
|
while dpg.is_dearpygui_running():
|
|
controller.update_frame(default_font)
|
|
dpg.render_dearpygui_frame()
|
|
finally:
|
|
controller.shutdown()
|
|
dpg.destroy_context()
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description="A tool for visualizing openpilot logs.")
|
|
parser.add_argument("--demo", action="store_true", help="Use the demo route instead of providing one")
|
|
parser.add_argument("--layout", type=str, help="Path to YAML layout file to load on startup")
|
|
parser.add_argument("route", nargs='?', default=None, help="Optional route name to load on startup.")
|
|
args = parser.parse_args()
|
|
route = DEMO_ROUTE if args.demo else args.route
|
|
main(route_to_load=route, layout_to_load=args.layout)
|