StarPilot/openpilot/system/ui/spinner.py

#!/usr/bin/env python3
import pyray as rl
import hashlib
from importlib.resources import as_file, files
import select
import sys

from openpilot.system.ui.lib.application import gui_app
from openpilot.system.ui.lib.text_measure import measure_text_cached
from openpilot.system.ui.text import wrap_text
from openpilot.system.ui.widgets import Widget

# Constants
if gui_app.big_ui():
  PROGRESS_BAR_WIDTH = 1000
  PROGRESS_BAR_HEIGHT = 20
  TEXTURE_SIZE = 360
  WRAPPED_SPACING = 50
  CENTERED_SPACING = 150
else:
  PROGRESS_BAR_WIDTH = 268
  PROGRESS_BAR_HEIGHT = 10
  TEXTURE_SIZE = 140
  WRAPPED_SPACING = 10
  CENTERED_SPACING = 20
DEGREES_PER_SECOND = 360.0  # one full rotation per second
MARGIN_H = 100
FONT_SIZE = 96
LINE_HEIGHT = 104
DARKGRAY = (55, 55, 55, 255)


def clamp(value, min_value, max_value):
  return max(min(value, max_value), min_value)


class Spinner(Widget):
  def __init__(self):
    super().__init__()
    self._hero_texture = None
    try:
      with as_file(files("openpilot.selfdrive").joinpath("assets/images/starpilot_boot.png")) as hero:
        expected = "f7da71fa91c961e8118d54756dae0324ecf74488cdd83d001b2c49a625f6a9de"
        if hero.stat().st_size == 493583 and hashlib.sha256(hero.read_bytes()).hexdigest() == expected:
          self._hero_texture = gui_app.texture("images/starpilot_boot.png", gui_app.width, gui_app.height)
    except (OSError, RuntimeError):
      pass
    self._comma_texture = gui_app.texture("images/spinner_comma.png", TEXTURE_SIZE, TEXTURE_SIZE)
    self._spinner_texture = gui_app.texture("images/spinner_track.png", TEXTURE_SIZE, TEXTURE_SIZE, alpha_premultiply=True)
    self._rotation = 0.0
    self._progress: int | None = None
    self._wrapped_lines: list[str] = []

  def set_text(self, text: str) -> None:
    if text.isdigit():
      self._progress = clamp(int(text), 0, 100)
      self._wrapped_lines = []
    else:
      self._progress = None
      font_size = (50 if gui_app.big_ui() else 22) if self._hero_texture is not None else FONT_SIZE
      self._wrapped_lines = wrap_text(text, font_size, gui_app.width - MARGIN_H)

  def _render(self, rect: rl.Rectangle):
    if self._hero_texture is not None:
      hero = self._hero_texture
      hero_region_height = rect.height * (0.72 if gui_app.big_ui() else 0.67)
      scale = min(rect.width / hero.width, hero_region_height / hero.height)
      width, height = hero.width * scale, hero.height * scale
      rl.draw_texture_pro(hero, rl.Rectangle(0, 0, hero.width, hero.height),
                          rl.Rectangle((rect.width - width) / 2, (hero_region_height - height) / 2, width, height),
                          rl.Vector2(0, 0), 0, rl.WHITE)
      if self._progress is not None:
        bar = rl.Rectangle(rect.width * 0.2, rect.height - (50 if gui_app.big_ui() else 18), rect.width * 0.6,
                           PROGRESS_BAR_HEIGHT)
        rl.draw_rectangle_rounded(bar, 1, 10, DARKGRAY)
        bar.width *= self._progress / 100.0
        rl.draw_rectangle_rounded(bar, 1, 10, rl.WHITE)
      elif self._wrapped_lines:
        font_size = 50 if gui_app.big_ui() else 22
        line_height = font_size * 1.1
        start_y = hero_region_height + (rect.height - hero_region_height - len(self._wrapped_lines) * line_height) / 2
        for i, line in enumerate(self._wrapped_lines):
          text_size = measure_text_cached(gui_app.font(), line, font_size)
          rl.draw_text_ex(gui_app.font(), line,
                          rl.Vector2((rect.width - text_size.x) / 2, start_y + i * line_height),
                          font_size, 0.0, rl.WHITE)
      return
    if self._wrapped_lines:
      # Calculate total height required for spinner and text
      spacing = WRAPPED_SPACING
      total_height = TEXTURE_SIZE + spacing + len(self._wrapped_lines) * LINE_HEIGHT
      center_y = (rect.height - total_height) / 2.0 + TEXTURE_SIZE / 2.0
    else:
      # Center spinner vertically
      spacing = CENTERED_SPACING
      center_y = rect.height / 2.0
    y_pos = center_y + TEXTURE_SIZE / 2.0 + spacing

    center = rl.Vector2(rect.width / 2.0, center_y)
    spinner_origin = rl.Vector2(TEXTURE_SIZE / 2.0, TEXTURE_SIZE / 2.0)
    comma_position = rl.Vector2(center.x - TEXTURE_SIZE / 2.0, center.y - TEXTURE_SIZE / 2.0)

    delta_time = rl.get_frame_time()
    self._rotation = (self._rotation + DEGREES_PER_SECOND * delta_time) % 360.0

    # Draw rotating spinner and static comma logo
    rl.draw_texture_pro(self._spinner_texture, rl.Rectangle(0, 0, TEXTURE_SIZE, TEXTURE_SIZE),
                        rl.Rectangle(center.x, center.y, TEXTURE_SIZE, TEXTURE_SIZE),
                        spinner_origin, self._rotation, rl.WHITE)
    rl.draw_texture_v(self._comma_texture, comma_position, rl.WHITE)

    # Display the progress bar or text based on user input
    if self._progress is not None:
      bar = rl.Rectangle(center.x - PROGRESS_BAR_WIDTH / 2.0, y_pos, PROGRESS_BAR_WIDTH, PROGRESS_BAR_HEIGHT)
      rl.draw_rectangle_rounded(bar, 1, 10, DARKGRAY)

      bar.width *= self._progress / 100.0
      rl.draw_rectangle_rounded(bar, 1, 10, rl.WHITE)
    elif self._wrapped_lines:
      for i, line in enumerate(self._wrapped_lines):
        text_size = measure_text_cached(gui_app.font(), line, FONT_SIZE)
        rl.draw_text_ex(gui_app.font(), line, rl.Vector2(center.x - text_size.x / 2, y_pos + i * LINE_HEIGHT),
                        FONT_SIZE, 0.0, rl.WHITE)


def _read_stdin():
  """Non-blocking read of available lines from stdin."""
  lines = []
  while True:
    rlist, _, _ = select.select([sys.stdin], [], [], 0.0)
    if not rlist:
      break
    line = sys.stdin.readline().strip()
    if line == "":
      break
    lines.append(line)
  return lines


def main():
  gui_app.init_window("Spinner")
  spinner = Spinner()
  for _ in gui_app.render():
    text_list = _read_stdin()
    if text_list:
      spinner.set_text(text_list[-1])

    spinner.render(rl.Rectangle(0, 0, gui_app.width, gui_app.height))


if __name__ == "__main__":
  main()