#187 Add new Track Painter

dmh23 · dmh23 · commit 9b5e4dc51aa7 · 2023-03-24T11:09:51.000Z
diff --git a/src/main/guru.py b/src/main/guru.py
@@ -2,7 +2,7 @@
 
 from PyQt6.QtCore import Qt
 from PyQt6.QtGui import QColor
-from PyQt6.QtWidgets import QMainWindow, QApplication, QProgressBar, QFileDialog
+from PyQt6.QtWidgets import QMainWindow, QApplication, QProgressBar, QFileDialog, QVBoxLayout, QLabel, QHBoxLayout
 
 from src.log.log import Log
 from src.configuration.config_manager import ConfigManager
@@ -14,6 +14,7 @@
 from src.tracks.tracks import get_all_tracks
 from src.ui.open_file_dialog import OpenFileDialog
 from ui.icons import get_custom_icon
+from ui.track_painter import TrackPainter
 
 
 class MainWindow(QMainWindow):
@@ -58,7 +59,23 @@ def __init__(self):
         # Canvas etc. comments TODO
 
         self.canvas = TrackAnalysisCanvas()
-        self.setCentralWidget(self.canvas)
+
+        centre_layout = QHBoxLayout()
+        centre_layout.addWidget(self.canvas)
+
+        analysis_controls_area = QLabel()
+        analysis_controls_area.setMinimumWidth(100)
+        analysis_controls_area.setMaximumWidth(100)
+        centre_layout.addWidget(analysis_controls_area)
+
+        centre_widget = QLabel()
+        centre_widget.setLayout(centre_layout)
+
+        self.setCentralWidget(centre_widget)
+
+
+
+
         self.make_status_bar_tall_enough_to_contain_progress_bar()
 
         self.show()
@@ -67,18 +84,33 @@ def __init__(self):
 
         self._tracks = get_all_tracks()
         self._current_track = self._tracks["arctic_pro_cw"]
-        self._current_track.configure_track_canvas(self.canvas)
 
-        track_grey = QColor(75, 75, 75)
-        grid_grey = QColor(45, 45, 45)
 
-        self._current_track.draw_track_edges(self.canvas, track_grey)
-        self._current_track.draw_waypoints(self.canvas, track_grey, 2, 8)
-        self._current_track.draw_section_highlight(self.canvas, track_grey, 0, 20)
-        self._current_track.draw_starting_line(self.canvas, track_grey)
-        self._current_track.draw_sector_dividers(self.canvas, track_grey)
-        self._current_track.draw_waypoint_labels(self.canvas, track_grey, 9)
-        self._current_track.draw_grid(self.canvas, grid_grey)
+        self._track_painter = TrackPainter()
+        from episode.episode_filter import EpisodeFilter
+        self._episode_filter = EpisodeFilter()
+
+
+        # Code that will move to the view menu etc.
+
+        self._track_painter.set_waypoint_sizes_micro()
+        self._track_painter.set_track_colour_blue()
+        self._track_painter.set_grid_back()
+        self._track_painter.set_waypoint_labels_on()
+        self._track_painter.set_sectors_on()
+
+        ## Code that will move to the analyzer
+
+        self._current_track.configure_track_canvas(self.canvas)
+        self._track_painter.draw(self.canvas, self._current_track, self._episode_filter)
+
+        # self._current_track.draw_track_edges(self.canvas, track_grey)
+        # self._current_track.draw_waypoints(self.canvas, track_grey, 2, 8)
+        # self._current_track.draw_section_highlight(self.canvas, track_grey, 0, 20)
+        # self._current_track.draw_starting_line(self.canvas, track_grey)
+        # self._current_track.draw_sector_dividers(self.canvas, track_grey)
+        # self._current_track.draw_waypoint_labels(self.canvas, track_grey, 9)
+        # self._current_track.draw_grid(self.canvas, grid_grey)
 
     def set_busy_cursor(self):
         self.setCursor(Qt.CursorShape.WaitCursor)
diff --git a/src/tracks/track.py b/src/tracks/track.py
@@ -149,7 +149,7 @@ def draw_starting_line(self, track_canvas: TrackAnalysisCanvas, colour: QColor):
     def draw_sector_dividers(self, track_canvas: TrackAnalysisCanvas, colour: QColor):
         for p in self._drawing_points:
             if p.is_divider:
-                track_canvas.add_fixed_shape(Line(p.left, p.right, 3, colour, (2, 3)))
+                track_canvas.add_fixed_shape(Line(p.left, p.right, 3, colour, (1, 2)))
 
     def draw_waypoints(self, track_canvas: TrackAnalysisCanvas, colour: QColor, minor_size: int, major_size: int):
         assert major_size >= minor_size
@@ -208,16 +208,16 @@ def draw_grid(self, track_canvas: TrackAnalysisCanvas, colour: QColor):
                 colour))
             y += 1
 
-    def draw_sector_labels(self, track_graphics: TrackGraphics, colour: str):
+    def draw_sector_labels(self, track_canvas: TrackAnalysisCanvas, colour: QColor):
         for name in self.get_all_sector_names():
             (start, finish) = self.get_sector_start_and_finish(name)
             label_waypoint = int((start + finish) / 2)
             point = self._drawing_points[label_waypoint].middle
 
             if self._is_vertical_at_waypoint(label_waypoint):
-                track_graphics.plot_text(point, name, 20, colour, 14, 0)
+                track_canvas.add_fixed_shape(Text(point, name, 18, colour, 14, 0))
             else:
-                track_graphics.plot_text(point, name, 20, colour, 0, -14)
+                track_canvas.add_fixed_shape(Text(point, name, 18, colour, 0, -14))
 
     def get_bearing_and_distance_to_next_waypoint(self, waypoint_id: int):
         this_point = self._drawing_points[waypoint_id].middle
diff --git a/src/ui/colours.py b/src/ui/colours.py
@@ -0,0 +1,8 @@
+from PyQt6.QtGui import QColor
+
+
+class Colours:
+    TRACK_GREY = QColor(75, 75, 75)
+    TRACK_BLUE = QColor(0, 0, 220)
+
+    GRID_GREY = QColor(45, 45, 45)
diff --git a/src/ui/track_painter.py b/src/ui/track_painter.py
@@ -0,0 +1,179 @@
+from episode.episode_filter import EpisodeFilter
+from graphics.track_analysis_canvas import TrackAnalysisCanvas
+from tracks.track import Track
+from ui.colours import Colours
+
+SECTOR_BORDER = 0.2
+
+class TrackPainter:
+    def __init__(self):
+        self.track_colour = Colours.TRACK_GREY
+
+        self.waypoint_major_size = 0
+        self.waypoint_minor_size = 0
+
+        self.waypoints_on = True
+        self.waypoint_labels_on = False
+        self.grid_on = False
+        self.annotations_on = False
+        self.sectors_on = False
+
+        self.drawing_order = [ "G", "A", "T", "N" ]
+
+        self.set_track_colour_grey()
+        self.set_waypoint_sizes_micro()
+
+        self.zoom_x = None
+        self.zoom_y = None
+        self.zoom_x2 = None
+        self.zoom_y2 = None
+
+        self.zoom_in = False
+
+    def set_track_colour_grey(self):
+        self.track_colour = Colours.TRACK_GREY
+
+    def set_track_colour_blue(self):
+        self.track_colour = Colours.TRACK_BLUE
+
+    def set_waypoint_sizes_large(self):
+        self.waypoint_minor_size = 5
+        self.waypoint_major_size = 9
+        self.waypoints_on = True
+
+    def set_waypoint_sizes_small(self):
+        self.waypoint_minor_size = 3
+        self.waypoint_major_size = 5
+        self.waypoints_on = True
+
+    def set_waypoint_sizes_micro(self):
+        self.waypoint_minor_size = 2
+        self.waypoint_major_size = 3
+        self.waypoints_on = True
+
+    def set_waypoints_off(self):
+        self.waypoints_on = False
+
+    def set_waypoint_labels_on(self):
+        self.waypoint_labels_on = True
+
+    def set_waypoint_labels_off(self):
+        self.waypoint_labels_on = False
+
+    def set_grid_front(self):
+        self.grid_on = True
+        self.drawing_order.remove("G")
+        self.drawing_order.append("G")
+
+    def set_grid_back(self):
+        self.grid_on = True
+        self.drawing_order.remove("G")
+        self.drawing_order.insert(0, "G")
+
+    def set_grid_off(self):
+        self.grid_on = False
+
+    def set_track_front(self):
+        self.drawing_order.remove("T")
+        self.drawing_order.append("T")
+
+    def set_track_back(self):
+        self.drawing_order.remove("T")
+        self.drawing_order.insert(0, "T")
+
+    def set_analyze_front(self):
+        self.drawing_order.remove("A")
+        self.drawing_order.append("A")
+
+    def set_analyze_back(self):
+        self.drawing_order.remove("A")
+        self.drawing_order.insert(0, "A")
+
+    def set_annotations_front(self):
+        self.annotations_on = True
+        self.drawing_order.remove("N")
+        self.drawing_order.append("N")
+
+    def set_annotations_back(self):
+        self.annotations_on = True
+        self.drawing_order.remove("N")
+        self.drawing_order.insert(0, "N")
+
+    def set_annotations_off(self):
+        self.annotations_on = False
+
+    def set_sectors_on(self):
+        self.sectors_on = True
+
+    def set_sectors_off(self):
+        self.sectors_on = False
+
+    def draw(self, track_canvas: TrackAnalysisCanvas, current_track: Track, episode_filter: EpisodeFilter):
+        # analyzer.recalculate()
+        # if background_analyser:
+        #     background_analyser.recalculate()
+        #
+        # track_graphics.reset_to_blank()
+        #
+        # if self.zoom_in and self.zoom_x:
+        #     track_graphics.set_track_area(self.zoom_x, self.zoom_y, self.zoom_x2, self.zoom_y2)
+        # else:
+        #     current_track.configure_track_graphics(track_graphics)
+
+        for do in self.drawing_order:
+            if do == "G" and self.grid_on:
+                current_track.draw_grid(track_canvas, Colours.GRID_GREY)
+
+            if do == "T":
+                current_track.draw_track_edges(track_canvas, self.track_colour)
+                if episode_filter.filter_complete_section:
+                    (start, finish) = episode_filter.filter_complete_section
+                    current_track.draw_section_highlight(track_canvas, self.track_colour, start, finish)
+
+                current_track.draw_starting_line(track_canvas, self.track_colour)
+                if self.sectors_on:
+                    current_track.draw_sector_dividers(track_canvas, self.track_colour)
+                    current_track.draw_sector_labels(track_canvas, self.track_colour)
+                if self.waypoints_on:
+                    current_track.draw_waypoints(track_canvas, self.track_colour, self.waypoint_minor_size,
+                                                 self.waypoint_major_size)
+                    if self.waypoint_labels_on:
+                        current_track.draw_waypoint_labels(track_canvas, self.track_colour, 9)
+
+            # if do == "A":
+            #     if background_analyser:
+            #         background_analyser.redraw()
+            #     analyzer.redraw()
+
+            if do == "N" and self.annotations_on:
+                current_track.draw_annotations(track_canvas)
+
+    # def zoom_set(self, track_graphics, x, y, x2, y2):
+    #     real_x, real_y = track_graphics.get_real_point_for_widget_location(x, y)
+    #     real_x2, real_y2 = track_graphics.get_real_point_for_widget_location(x2, y2)
+    #
+    #     self.zoom_x = min(real_x, real_x2)
+    #     self.zoom_x2 = max(real_x, real_x2)
+    #     self.zoom_y = min(real_y, real_y2)
+    #     self.zoom_y2 = max(real_y, real_y2)
+    #
+    #     self.zoom_in = True
+    #
+    # def zoom_sector(self, track: Track, sector: str):
+    #     (self.zoom_x, self.zoom_y, self.zoom_x2, self.zoom_y2) = track.get_sector_coordinates(sector)
+    #     self.zoom_x -= SECTOR_BORDER
+    #     self.zoom_y -= SECTOR_BORDER
+    #     self.zoom_x2 += SECTOR_BORDER
+    #     self.zoom_y2 += SECTOR_BORDER
+    #     self.zoom_in = True
+    #
+    # def zoom_toggle(self):
+    #     self.zoom_in = not self.zoom_in
+    #
+    # def zoom_clear(self):
+    #     self.zoom_x = None
+    #     self.zoom_y = None
+    #     self.zoom_x2 = None
+    #     self.zoom_y2 = None
+    #
+    #     self.zoom_in = False
