#187 New drawing of track sector dividers and waypoint labels

Author: dmh23

src/graphics/track_analysis_canvas.py

@@ -5,9 +5,11 @@
 
 from graphics.canvas import Canvas
 from PyQt6.QtWidgets import QAbstractGraphicsShapeItem
-from PyQt6.QtGui import QPen, QPainter, QBrush
+from PyQt6.QtGui import QPen, QPainter, QBrush, QColor, QFont
 from PyQt6.QtCore import Qt
 
+from utils import geometry
+
 Point = (float | int, float | int)     # Typedef which we will use a lot for graphics
 
 
@@ -111,7 +113,7 @@ def add_fixed_shape(self, item: FixedShape):
 # plot_dot() in v3
 
 class FilledCircle(FixedShape):
-    def __init__(self, point: Point, diameter: int, colour: Qt.GlobalColor):
+    def __init__(self, point: Point, diameter: int, colour: QColor):
         self._point = point
         self._pen = QPen(colour)
         self._diameter = diameter
@@ -133,11 +135,13 @@ def paint(self, painter: QPainter, scale: Scale):
 # def plot_line(self, point1, point2, width, fill_colour, dash_pattern=None)    in v3
 
 class Line(FixedShape):
-    def __init__(self, start: Point, finish: Point, width: int, colour: Qt.GlobalColor, dash_pattern="??????"):
+    def __init__(self, start: Point, finish: Point, width: int, colour: QColor, dash_pattern: (int, int) = None):
         self._start = start
         self._finish = finish
         self._pen = QPen(colour)
         self._pen.setWidth(width)
+        if dash_pattern:
+            self._pen.setDashPattern(dash_pattern)
 
     def paint(self, painter: QPainter, scale: Scale):
         x1, y1 = scale.apply(self._start)
@@ -146,4 +150,38 @@ def paint(self, painter: QPainter, scale: Scale):
         painter.drawLine(x1, y1, x2, y2)
 
 
+# The point given is the approximate CENTRE of the text
+
+class Text(FixedShape):
+    last_non_overlapping_text_position = None
+
+    def __init__(self, position: Point, text: str, font_size: int, colour: QColor, offset_x: int = 0, offset_y: int = 0):
+        self._position = position
+        self._text = text
+        self._offset_x = offset_x
+        self._offset_y = offset_y
+        self._centering_x_offset = 0.4 * font_size * len(text)
+        self._centering_y_offset = 0.5 * font_size
+        self._spacing = 2.3 * font_size
+
+        self._pen = QPen(colour)
+        self._font = QFont()
+        self._font.setPointSize(font_size)
+        # self._font.setStyleStrategy(QFont.StyleStrategy.NoAntialias)
+
+    def paint(self, painter: QPainter, scale: Scale):
+        x, y = scale.apply(self._position)
+
+        x = round(x + self._offset_x - self._centering_x_offset)
+        y = round(y + self._offset_y + self._centering_y_offset)
+
+        if Text.last_non_overlapping_text_position:
+            dist = geometry.get_distance_between_points(self.last_non_overlapping_text_position, (x, y))
+            if dist < self._spacing:
+                return
+
+        painter.setPen(self._pen)
+        painter.setFont(self._font)
+        painter.drawText(x, y, self._text)
 
+        Text.last_non_overlapping_text_position = (x, y)

src/prototype_ui/main.py

@@ -1,6 +1,7 @@
 import sys
 
 from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QColor
 from PyQt6.QtWidgets import QMainWindow, QApplication, QProgressBar, QFileDialog
 
 from src.log.log import Log
@@ -68,9 +69,12 @@ def __init__(self):
         self._current_track = self._tracks["arctic_pro_cw"]
         self._current_track.configure_track_canvas(self.canvas)
 
-        self._current_track.draw_track_edges(self.canvas, Qt.GlobalColor.darkGray)
-        self._current_track.draw_waypoints(self.canvas, Qt.GlobalColor.blue, 3, 4)
-        self._current_track.draw_section_highlight(self.canvas, Qt.GlobalColor.green, 0, 20)
+        self._current_track.draw_track_edges(self.canvas, QColor("dimGray"))
+        self._current_track.draw_waypoints(self.canvas, QColor("dimGray"), 2, 8)
+        self._current_track.draw_section_highlight(self.canvas, QColor("dimGray"), 0, 20)
+        self._current_track.draw_starting_line(self.canvas, QColor("dimGray"))
+        self._current_track.draw_sector_dividers(self.canvas, QColor("dimGray"))
+        self._current_track.draw_waypoint_labels(self.canvas, QColor("dimGray"), 9)
 
     def set_busy_cursor(self):
         self.setCursor(Qt.CursorShape.WaitCursor)

src/tracks/track.py

@@ -9,9 +9,10 @@
 # Copyright (c) 2021 dmh23
 #
 from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QColor
 
 import src.utils.geometry as geometry
-from graphics.track_analysis_canvas import TrackAnalysisCanvas, TrackArea, Line, FilledCircle
+from graphics.track_analysis_canvas import TrackAnalysisCanvas, TrackArea, Line, FilledCircle, Text
 from src.analyze.util.heatmap import HeatMap
 from src.analyze.util.visitor import VisitorMap
 from src.configuration.real_world import VEHICLE_LENGTH, VEHICLE_WIDTH, BOX_OBSTACLE_WIDTH, BOX_OBSTACLE_LENGTH
@@ -116,7 +117,7 @@ def configure_track_canvas(self, canvas: TrackAnalysisCanvas):
                          self._max_x + DISPLAY_BORDER, self._max_y + DISPLAY_BORDER)
         canvas.set_track_area(area)
 
-    def draw_track_edges(self, track_canvas: TrackAnalysisCanvas, colour: Qt.GlobalColor):
+    def draw_track_edges(self, track_canvas: TrackAnalysisCanvas, colour: QColor):
         previous_left = self._drawing_points[-1].left
         previous_right = self._drawing_points[-1].right
 
@@ -126,7 +127,7 @@ def draw_track_edges(self, track_canvas: TrackAnalysisCanvas, colour: Qt.GlobalC
             track_canvas.add_fixed_shape(Line(previous_right, p.right, 2, colour))
             previous_right = p.right
 
-    def draw_section_highlight(self, track_canvas: TrackAnalysisCanvas, colour: Qt.GlobalColor, start: int, finish: int):
+    def draw_section_highlight(self, track_canvas: TrackAnalysisCanvas, colour: QColor, start: int, finish: int):
         previous_left = self._drawing_points[start].left_outer
         previous_right = self._drawing_points[start].right_outer
 
@@ -136,42 +137,51 @@ def draw_section_highlight(self, track_canvas: TrackAnalysisCanvas, colour: Qt.G
             highlight_points = self._drawing_points[start:] + self._drawing_points[:finish + 1]
 
         for p in highlight_points:
-            track_canvas.add_fixed_shape(Line(previous_left, p.left_outer, 3, colour))
+            track_canvas.add_fixed_shape(Line(previous_left, p.left_outer, 4, colour))
             previous_left = p.left_outer
-            track_canvas.add_fixed_shape(Line(previous_right, p.right_outer, 3, colour))
+            track_canvas.add_fixed_shape(Line(previous_right, p.right_outer, 4, colour))
             previous_right = p.right_outer
 
-    def draw_starting_line(self, track_graphics: TrackGraphics, colour: str):
-        track_graphics.plot_line(self._drawing_points[0].left, self._drawing_points[0].right, 3, colour)
+    def draw_starting_line(self, track_canvas: TrackAnalysisCanvas, colour: QColor):
+        track_canvas.add_fixed_shape(Line(self._drawing_points[0].left, self._drawing_points[0].right, 3, colour))
 
-    def draw_sector_dividers(self, track_graphics: TrackGraphics, colour: str):
+    def draw_sector_dividers(self, track_canvas: TrackAnalysisCanvas, colour: QColor):
         for p in self._drawing_points:
             if p.is_divider:
-                track_graphics.plot_line(p.left, p.right, 3, colour, (4, 2))
+                track_canvas.add_fixed_shape(Line(p.left, p.right, 2, colour, (2, 3)))
 
-    def draw_waypoints(self, track_canvas: TrackAnalysisCanvas, colour: Qt.GlobalColor, minor_size: int, major_size: int):
+    def draw_waypoints(self, track_canvas: TrackAnalysisCanvas, colour: QColor, minor_size: int, major_size: int):
         assert major_size >= minor_size
         for (i, p) in enumerate(self._drawing_points):
             if i % 10 == 0:
                 track_canvas.add_fixed_shape(FilledCircle(p.middle, major_size, colour))
             else:
                 track_canvas.add_fixed_shape(FilledCircle(p.middle, minor_size, colour))
 
-    def draw_waypoint_labels(self, track_graphics: TrackGraphics, colour: str, font_size: int):
+    def draw_waypoint_labels(self, track_canvas: TrackAnalysisCanvas, colour: QColor, font_size: int):
         last_label_position = None
-        for (i, p) in enumerate(self._drawing_points[:-2]):
+        for (i, p) in enumerate(self._drawing_points[1:-2]):
             if self._is_vertical_at_waypoint(i):
-                label = track_graphics.plot_text(p.middle, str(i), font_size, colour, -1.5 * font_size, 0.0)
-            else:
-                label = track_graphics.plot_text(p.middle, str(i), font_size, colour, 0.0, 1.5 * font_size)
-
-            label_position = track_graphics.get_widget_position(label)
-            if last_label_position is None:
-                last_label_position = label_position
-            elif geometry.get_distance_between_points(last_label_position, label_position) < 2.5 * font_size:
-                track_graphics.delete_widget(label)
+                y_offset = 0
+                if i >= 99:
+                    x_offset = -round(1.5 * font_size)
+                else:
+                    x_offset = -font_size
             else:
-                last_label_position = label_position
+                x_offset = 0
+                y_offset = font_size + 2
+
+            track_canvas.add_fixed_shape(Text(p.middle, str(i+1), font_size, colour, x_offset, y_offset))
+            # track_canvas.add_fixed_shape(Text(p.middle, str(i+1), font_size, colour))
+
+            # TODO Clever stuff to skip labels which would be too close together!
+            # label_position = track_canvas.get_widget_position(label)
+            # if last_label_position is None:
+            #     last_label_position = label_position
+            # elif geometry.get_distance_between_points(last_label_position, label_position) < 2.5 * font_size:
+            #     track_graphics.delete_widget(label)
+            # else:
+            #     last_label_position = label_position
 
     def draw_annotations(self, track_graphics: TrackGraphics):
         for a in self._annotations: