IQ.Pilot Release Commit @ 9fe0487

iqpilot/iq_maps/update_vendor_version.py

@@ -14,12 +14,14 @@ from openpilot.common.basedir import BASEDIR
 from openpilot.iqpilot.iq_maps import VENDOR_MAPD_PATH
 from openpilot.iqpilot.iq_maps.vendor_mapd_installer import (
   VENDOR_RELEASE_TAG,
-  get_file_hash,
+  sha256_of_file,
 )
 
 _RELEASE_SYMBOL = "VENDOR_RELEASE_TAG"
 _INSTALLER_SRC = os.path.join(BASEDIR, "iqpilot", "iq_maps", "vendor_mapd_installer.py")
-_HASH_FILE = os.path.join(BASEDIR, "iqpilot", "iq_maps", "tests", "mapd_hash")
+# public: the checked-in hash the version test compares the installed binary against
+HASH_FILE = os.path.join(BASEDIR, "iqpilot", "iq_maps", "tests", "mapd_hash")
+_HASH_FILE = HASH_FILE
 _TAG_ASSIGN = re.compile(rf'^{_RELEASE_SYMBOL}\s*=\s*["\'][^"\']*["\']', re.MULTILINE)
 
 
@@ -39,7 +41,7 @@ def rewrite_pinned_tag(new_tag: str) -> bool:
 
 
 def refresh_hash_file() -> None:
-  digest = get_file_hash(VENDOR_MAPD_PATH)
+  digest = sha256_of_file(VENDOR_MAPD_PATH)
   with open(_HASH_FILE, "w") as f:
     f.write(digest)
   print(f"wrote binary hash {digest} -> {_HASH_FILE}")

iqpilot/iq_maps/vendor_mapd_installer.py

@@ -34,7 +34,7 @@ _NET_PROBE_ATTEMPTS = 10
 _NET_PROBE_INTERVAL_S = 2
 
 
-def get_file_hash(path: str) -> str:
+def sha256_of_file(path: str) -> str:
   """Hex SHA-256 digest of a file on disk."""
   digest = hashlib.sha256()
   with open(path, "rb") as handle:
@@ -103,7 +103,7 @@ class VendorMapdInstaller:
     if not reference:
       return True
     try:
-      return get_file_hash(VENDOR_MAPD_PATH) == reference
+      return sha256_of_file(VENDOR_MAPD_PATH) == reference
     except OSError:
       return False
 

iqpilot/selfdrive/car/interfaces.py

@@ -69,7 +69,7 @@ def _cleanup_unsupported_params(cp, cp_iq, store=None) -> None:
   set_speed_limit_controller_availability(cp, cp_iq, store)
 
 
-def setup_interfaces(ci, store=None) -> None:
+def apply_iq_car_config(ci, store=None) -> None:
   store = store or _Store()
   if _stamp_lateral_model(ci.CP, ci.CP_IQ, store):
     ci.configure_torque_tune(ci.CP.carFingerprint, ci.CP.lateralTuning)

iqpilot/selfdrive/car/vehicle_catalog.py

@@ -81,5 +81,5 @@ def _write(vehicles: dict[str, dict], basedir: str = BASEDIR) -> str:
 
 
 if __name__ == "__main__":
-  from iqdbc.iqpilot.car.platform_list import get_car_list
+  from iqdbc.lvbs.car.platform_list import get_car_list
   print("wrote", _write(get_car_list()))

iqpilot/selfdrive/controls/lib/helpers/e2e_alerts.py

@@ -4,152 +4,140 @@ Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed
 
 from cereal import messaging, custom
 
+from openpilot.common.params import Params
 from openpilot.common.realtime import DT_MDL
 from openpilot.iqpilot.selfdrive.selfdrived.events import IQEvents
 
-PATH_QUEUE_GATE = 30
-LEAD_GROWTH_GATE = 1.0
-TRIGGER_HOLD_S = 0.3
+PARAM_PATH = "EndToEndAlert"
+PARAM_LEAD = "EndToEndLeadAlert"
+PARAM_STRIDE_S = 2.0
+
+SETTLE_S = 1.0
+CONFIRM_S = 0.4
+ROLL_MPS = 0.3
+
+HORIZON_TAIL = 5
+PATH_SPEED_MPS = 3.0
+
+LEAD_QUEUE_M = 12.0
+LEAD_SPEED_MPS = 1.0
+LEAD_GAP_M = 0.5
 
 
-class TriggerPhase:
-  IDLE = 0
-  ARMED = 1
-  FIRED = 2
+class _Confirm:
+  def __init__(self, window_s: float):
+    self._window = window_s
+    self._held = 0.0
+    self._spent = False
+
+  def clear(self) -> None:
+    self._held = 0.0
+    self._spent = False
+
+  def poll(self, holds: bool) -> bool:
+    if self._spent:
+      return False
+    self._held = self._held + DT_MDL if holds else 0.0
+    if self._held < self._window:
+      return False
+    self._spent = True
+    return True
 
 
-class StopAndLeadChimeEngine:
+class _Dwell:
   def __init__(self):
-    self._frame = -1
-    self._toggle = {"path_queue": False, "lead_depart": False}
-    self._trigger = {
-      "path_queue": {"phase": TriggerPhase.IDLE, "last_phase": TriggerPhase.IDLE, "fired": False, "hold_ticks": 0, "anchor": -1.0},
-      "lead_depart": {"phase": TriggerPhase.IDLE, "last_phase": TriggerPhase.IDLE, "fired": False, "hold_ticks": 0, "anchor": -1.0},
-    }
-    self._standstill_gate = {"open": False, "was_open": False, "moving_frame": -1}
-    self._lead_state = {"visible": False, "primed": False, "armed": False, "warmup_ticks": 0}
+    self.seconds = 0.0
+    self.lead_floor = float('inf')
 
-  def _read_toggles(self) -> None:
-    self._toggle["path_queue"] = False
-    self._toggle["lead_depart"] = False
+  def clear(self) -> None:
+    self.seconds = 0.0
+    self.lead_floor = float('inf')
 
-  def _mark_motion(self, standstill: bool, speed_mps: float) -> bool:
-    is_moving = (not standstill) and speed_mps > 0.1
-    if is_moving:
-      self._standstill_gate["moving_frame"] = self._frame
-    return is_moving
+  def tick(self, lead_range: float | None) -> None:
+    self.seconds += DT_MDL
+    if lead_range is not None:
+      self.lead_floor = min(self.lead_floor, lead_range)
 
-  def _within_motion_grace(self) -> bool:
-    stamp = self._standstill_gate["moving_frame"]
-    if stamp == -1:
-      return True
-    return (self._frame - stamp) * DT_MDL < 2.0
+  @property
+  def settled(self) -> bool:
+    return self.seconds >= SETTLE_S
 
-  def _update_gate(self, standstill: bool, speed_mps: float, gas_pressed: bool, controls_enabled: bool) -> None:
-    moving = self._mark_motion(standstill, speed_mps)
-    self._standstill_gate["open"] = (not moving) and (not gas_pressed) and (not controls_enabled) and (not self._within_motion_grace())
+  @property
+  def queued(self) -> bool:
+    return self.lead_floor < LEAD_QUEUE_M
 
-  @staticmethod
-  def _path_end_x(path_x):
-    return float(path_x[-1]) if len(path_x) else 0.0
 
-  def _path_queue_signal(self, path_x) -> bool:
-    node = self._trigger["path_queue"]
-    if node["phase"] != TriggerPhase.ARMED:
-      node["hold_ticks"] = 0
-      return False
-    node["hold_ticks"] = node["hold_ticks"] + 1 if self._path_end_x(path_x) > PATH_QUEUE_GATE else 0
-    return node["hold_ticks"] * DT_MDL > TRIGGER_HOLD_S
+class EndToEndAlertEngine:
+  def __init__(self):
+    self._params = Params()
+    self._on = {"path": False, "lead": False}
+    self._elapsed_since_read = PARAM_STRIDE_S
+    self._dwell = _Dwell()
+    self._confirm = {"path": _Confirm(CONFIRM_S), "lead": _Confirm(CONFIRM_S)}
+    self._fired = {"path": False, "lead": False}
 
-  def _update_lead_prime(self, seen: bool, distance_m: float) -> None:
-    near_lead = seen and distance_m < 8.0
-    opened_now = self._standstill_gate["open"] and not self._standstill_gate["was_open"]
-
-    if opened_now and near_lead:
-      self._lead_state["primed"] = True
-    elif not self._standstill_gate["open"]:
-      self._lead_state["primed"] = False
-
-    if self._standstill_gate["open"] and self._lead_state["primed"] and near_lead:
-      self._lead_state["warmup_ticks"] += 1
-      self._lead_state["armed"] = self._lead_state["warmup_ticks"] * DT_MDL >= 1.0
+  def _refresh_params(self) -> None:
+    self._elapsed_since_read += DT_MDL
+    if self._elapsed_since_read < PARAM_STRIDE_S:
       return
-
-    self._lead_state["warmup_ticks"] = 0
-    self._lead_state["armed"] = False
-
-  def _lead_depart_signal(self, distance_m: float) -> bool:
-    node = self._trigger["lead_depart"]
-    if node["phase"] != TriggerPhase.ARMED:
-      node["anchor"] = -1.0
-      node["hold_ticks"] = 0
-      return False
-
-    if node["anchor"] == -1.0 or distance_m < node["anchor"]:
-      node["anchor"] = distance_m
-
-    grew = node["anchor"] != -1.0 and (distance_m - node["anchor"]) > LEAD_GROWTH_GATE
-    node["hold_ticks"] = node["hold_ticks"] + 1 if grew else 0
-    return node["hold_ticks"] * DT_MDL > TRIGGER_HOLD_S
-
-  def _sample_inputs(self, sm: messaging.SubMaster):
-    cs = sm['carState']
-    cc = sm['carControl']
-    lead_one = sm['radarState'].leadOne
-
-    self._lead_state["visible"] = lead_one.status
-    lead_distance = lead_one.dRel
-
-    self._update_gate(cs.standstill, cs.vEgo, cs.gasPressed, cc.enabled)
-    queue_fire = self._path_queue_signal(sm['modelV2'].position.x)
-    self._update_lead_prime(self._lead_state["visible"], lead_distance)
-    lead_fire = self._lead_depart_signal(lead_distance)
-
-    self._standstill_gate["was_open"] = self._standstill_gate["open"]
-    return queue_fire, lead_fire
+    self._elapsed_since_read = 0.0
+    self._on["path"] = self._params.get_bool(PARAM_PATH)
+    self._on["lead"] = self._params.get_bool(PARAM_LEAD)
 
   @staticmethod
-  def _step_phase(phase: int, enabled: bool, allowed: bool, fired: bool) -> tuple[int, bool]:
-    if phase == TriggerPhase.IDLE:
-      return (TriggerPhase.ARMED, fired) if (allowed and enabled) else (phase, fired)
-    if not allowed or not enabled:
-      return TriggerPhase.IDLE, fired
-    if phase == TriggerPhase.ARMED and fired:
-      return TriggerPhase.FIRED, fired
-    return phase, fired
+  def _car_holds_long(sm: messaging.SubMaster) -> bool:
+    # AOL steers without raising selfdriveState.enabled, so the pair reads as long authority
+    return bool(sm['selfdriveState'].enabled or sm['carState'].cruiseState.enabled)
 
-  def _advance_trigger(self, key: str, enabled: bool, allowed: bool, fired: bool) -> None:
-    node = self._trigger[key]
-    node["last_phase"] = node["phase"]
-    node["phase"], node["fired"] = self._step_phase(node["phase"], enabled, allowed, fired)
+  @staticmethod
+  def _halted(cs) -> bool:
+    return bool(cs.standstill) or abs(cs.vEgo) < ROLL_MPS
+
+  @staticmethod
+  def _horizon_speed(model) -> float:
+    # capnp list readers reject slices
+    samples = model.velocity.x
+    count = len(samples)
+    if count < HORIZON_TAIL:
+      return 0.0
+    return sum(samples[i] for i in range(count - HORIZON_TAIL, count)) / HORIZON_TAIL
+
+  def _rearm(self) -> None:
+    self._dwell.clear()
+    for gate in self._confirm.values():
+      gate.clear()
 
   def update(self, sm: messaging.SubMaster, iq_events: IQEvents) -> None:
-    self._read_toggles()
-    queue_fire, lead_fire = self._sample_inputs(sm)
+    self._refresh_params()
+    self._fired["path"] = self._fired["lead"] = False
 
-    self._advance_trigger("path_queue", self._toggle["path_queue"], self._standstill_gate["open"] and not self._lead_state["visible"], queue_fire)
-    self._advance_trigger("lead_depart", self._toggle["lead_depart"], self._standstill_gate["open"] and self._lead_state["armed"], lead_fire)
+    cs = sm['carState']
+    lead = sm['radarState'].leadOne
+    lead_range = float(lead.dRel) if lead.status else None
 
-    if self._trigger["path_queue"]["fired"] or self._trigger["lead_depart"]["fired"]:
+    if not self._halted(cs) or cs.gasPressed or self._car_holds_long(sm):
+      self._rearm()
+      return
+
+    self._dwell.tick(lead_range)
+    if not self._dwell.settled:
+      return
+
+    if self._on["path"] and lead_range is None:
+      opened = self._horizon_speed(sm['modelV2']) > PATH_SPEED_MPS
+      self._fired["path"] = self._confirm["path"].poll(opened)
+
+    if self._on["lead"] and lead_range is not None and self._dwell.queued:
+      pulling = lead.vLead > LEAD_SPEED_MPS and (lead_range - self._dwell.lead_floor) > LEAD_GAP_M
+      self._fired["lead"] = self._confirm["lead"].poll(pulling)
+
+    if self._fired["path"] or self._fired["lead"]:
       iq_events.add(custom.IQOnroadEvent.EventName.e2eChime)
 
-    self._frame += 1
+  @property
+  def path_alert(self) -> bool:
+    return self._fired["path"]
 
   @property
-  def queue_alert(self):
-    return self._trigger["path_queue"]["fired"]
-
-  @queue_alert.setter
-  def queue_alert(self, payload):
-    self._trigger["path_queue"]["fired"] = bool(payload)
-
-  @property
-  def lead_alert(self):
-    return self._trigger["lead_depart"]["fired"]
-
-  @lead_alert.setter
-  def lead_alert(self, payload):
-    self._trigger["lead_depart"]["fired"] = bool(payload)
-
-
-E2EAlertsHelper = StopAndLeadChimeEngine
+  def lead_alert(self) -> bool:
+    return self._fired["lead"]

iqpilot/selfdrive/controls/lib/helpers/tests/test_e2e_alerts.py

@@ -0,0 +1,133 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos
+"""
+from types import SimpleNamespace
+
+import pytest
+
+import cereal.messaging as messaging
+from cereal import custom
+from openpilot.common.realtime import DT_MDL
+from openpilot.iqpilot.selfdrive.controls.lib.helpers.e2e_alerts import (
+  EndToEndAlertEngine, CONFIRM_S, SETTLE_S, HORIZON_TAIL, PATH_SPEED_MPS, LEAD_SPEED_MPS, LEAD_GAP_M)
+
+E2E_CHIME = custom.IQOnroadEvent.EventName.e2eChime
+
+
+class _Events(list):
+  def add(self, name):
+    self.append(name)
+
+
+def _model(horizon):
+  msg = messaging.new_message('modelV2')
+  msg.modelV2.velocity.x = [0.0] * (33 - HORIZON_TAIL) + [horizon] * HORIZON_TAIL
+  return msg.as_reader().modelV2
+
+
+def _sm(*, v_ego=0.0, standstill=True, gas=False, enabled=False, cruise=False,
+        horizon=0.0, lead=None):
+  lead = lead or SimpleNamespace(status=False, dRel=0.0, vLead=0.0)
+  return {
+    'carState': SimpleNamespace(vEgo=v_ego, standstill=standstill, gasPressed=gas,
+                                cruiseState=SimpleNamespace(enabled=cruise)),
+    'selfdriveState': SimpleNamespace(enabled=enabled),
+    'radarState': SimpleNamespace(leadOne=lead),
+    'modelV2': _model(horizon),
+  }
+
+
+def _engine(path=True, lead=True):
+  engine = EndToEndAlertEngine()
+  engine._refresh_params = lambda: None
+  engine._on = {"path": path, "lead": lead}
+  return engine
+
+
+def _run(engine, sm, seconds):
+  events = _Events()
+  chimes = 0
+  for _ in range(int(seconds / DT_MDL)):
+    engine.update(sm, events)
+    chimes += events.count(E2E_CHIME)
+    events.clear()
+  return chimes
+
+
+def _lead(d_rel, v_lead=0.0):
+  return SimpleNamespace(status=True, dRel=d_rel, vLead=v_lead)
+
+
+def test_path_opens_chimes_once():
+  engine = _engine()
+  assert _run(engine, _sm(horizon=0.0), SETTLE_S + 1.0) == 0
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0), CONFIRM_S + 1.0) == 1
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0), 5.0) == 0
+
+
+def test_path_needs_the_settle_dwell():
+  engine = _engine()
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0), SETTLE_S - 0.2) == 0
+
+
+def test_path_silent_while_openpilot_long_is_engaged():
+  engine = _engine()
+  _run(engine, _sm(horizon=0.0, enabled=True), SETTLE_S + 1.0)
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0, enabled=True), 5.0) == 0
+
+
+def test_path_silent_while_stock_acc_holds_the_car():
+  engine = _engine()
+  _run(engine, _sm(horizon=0.0, cruise=True), SETTLE_S + 1.0)
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0, cruise=True), 5.0) == 0
+
+
+def test_path_chimes_under_aol():
+  engine = _engine()
+  _run(engine, _sm(horizon=0.0), SETTLE_S + 1.0)
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0), CONFIRM_S + 1.0) == 1
+
+
+def test_path_ignores_a_visible_lead():
+  engine = _engine(lead=False)
+  _run(engine, _sm(horizon=0.0, lead=_lead(6.0)), SETTLE_S + 1.0)
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0, lead=_lead(6.0)), 5.0) == 0
+
+
+def test_lead_pullaway_chimes_once():
+  engine = _engine()
+  assert _run(engine, _sm(lead=_lead(6.0)), SETTLE_S + 1.0) == 0
+  moving = _sm(lead=_lead(6.0 + LEAD_GAP_M + 0.5, LEAD_SPEED_MPS + 1.0))
+  assert _run(engine, moving, CONFIRM_S + 1.0) == 1
+  assert _run(engine, moving, 5.0) == 0
+
+
+def test_lead_creep_inside_the_gap_stays_silent():
+  engine = _engine()
+  _run(engine, _sm(lead=_lead(6.0)), SETTLE_S + 1.0)
+  assert _run(engine, _sm(lead=_lead(6.0 + LEAD_GAP_M / 2, LEAD_SPEED_MPS + 1.0)), 5.0) == 0
+
+
+def test_lead_far_ahead_is_not_a_queue():
+  engine = _engine()
+  _run(engine, _sm(lead=_lead(40.0)), SETTLE_S + 1.0)
+  assert _run(engine, _sm(lead=_lead(44.0, LEAD_SPEED_MPS + 1.0)), 5.0) == 0
+
+
+def test_gas_and_motion_rearm_the_dwell():
+  engine = _engine()
+  _run(engine, _sm(horizon=0.0), SETTLE_S + 1.0)
+  _run(engine, _sm(v_ego=5.0, standstill=False, horizon=8.0), 2.0)
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0), SETTLE_S - 0.2) == 0
+  assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0), CONFIRM_S + 1.0) == 1
+
+
+@pytest.mark.parametrize("param_off", ["path", "lead"])
+def test_each_param_gates_only_its_own_trigger(param_off):
+  engine = _engine(path=param_off != "path", lead=param_off != "lead")
+  if param_off == "path":
+    _run(engine, _sm(horizon=0.0), SETTLE_S + 1.0)
+    assert _run(engine, _sm(horizon=PATH_SPEED_MPS + 2.0), 5.0) == 0
+  else:
+    _run(engine, _sm(lead=_lead(6.0)), SETTLE_S + 1.0)
+    assert _run(engine, _sm(lead=_lead(8.0, LEAD_SPEED_MPS + 1.0)), 5.0) == 0

iqpilot/selfdrive/controls/lib/longitudinal_planner.py

@@ -13,7 +13,7 @@ from openpilot.selfdrive.car.cruise import V_CRUISE_MAX
 from openpilot.iqpilot.selfdrive.controls.lib.custom_stop_distance import CustomStopDistance
 from openpilot.iqpilot.selfdrive.controls.lib.iq_dynamic.engine import IQDynamicController
 from openpilot.iqpilot.selfdrive.controls.lib.iq_dynamic.imahelper import IQConstants
-from openpilot.iqpilot.selfdrive.controls.lib.helpers.e2e_alerts import E2EAlertsHelper
+from openpilot.iqpilot.selfdrive.controls.lib.helpers.e2e_alerts import EndToEndAlertEngine
 from openpilot.iqpilot.selfdrive.controls.lib.slc_vcruise import SLCVCruise
 from openpilot.iqpilot.selfdrive.controls.lib.speed_limit_controller import LIMIT_ADAPT_ACC
 from openpilot.iqpilot.selfdrive.selfdrived.events import IQEvents
@@ -34,7 +34,7 @@ class LongitudinalPlannerIQ:
     self.slimit = SLCVCruise()
     self.generation = int(model_bundle.generation) if (model_bundle := get_active_bundle()) else None
     self.source = LongitudinalPlanSource.cruise
-    self.iqmodeloutput = E2EAlertsHelper()
+    self.e2e_alerts = EndToEndAlertEngine()
     self.output_v_target = 0.
     self.output_a_target = 0.
     self.speed_limit_last = 0.
@@ -146,7 +146,7 @@ class LongitudinalPlannerIQ:
     for event_name in getattr(self.slimit, 'pending_events', []):
       self.events_iq.add(event_name)
     self.custom_stop_distance.update()
-    self.iqmodeloutput.update(sm, self.events_iq)
+    self.e2e_alerts.update(sm, self.events_iq)
     if bool(getattr(sm["iqCarState"], "alcOverrideAlert", False)):
       self.events_iq.add(custom.IQOnroadEvent.EventName.steeringOverrideReengageAlc)
 
@@ -244,10 +244,9 @@ class LongitudinalPlannerIQ:
       assist.vTarget = float(self.output_v_target if assist.active else 255.)
       assist.aTarget = float(self.slimit.slc_a_target if assist.active else 0.)
 
-      # E2E Alerts
       e2eAlerts = plan_msg.e2eAlerts
-      e2eAlerts.greenLightAlert = self.iqmodeloutput.queue_alert
-      e2eAlerts.leadDepartAlert = self.iqmodeloutput.lead_alert
+      e2eAlerts.pathOpen = self.e2e_alerts.path_alert
+      e2eAlerts.leadPullaway = self.e2e_alerts.lead_alert
 
     valid = sm.all_checks(service_list=['carState', 'controlsState'])
 

iqpilot/ui/layouts/settings/iq_dynamic.py

@@ -8,8 +8,8 @@ import pyray as rl
 from openpilot.common.params import Params
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.iqpilot.widgets.list_view import IQListItem, IQToggleAction, SafeIQToggleAction
-from openpilot.system.ui.iqpilot.widgets.list_view import OptionControl
+from openpilot.system.ui.iqwidgets.widgets.list_view import IQListItem, IQToggleAction, SafeIQToggleAction
+from openpilot.system.ui.iqwidgets.widgets.list_view import OptionControl
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.network import NavButton
 from openpilot.system.ui.widgets.scroller_tici import Scroller

iqpilot/ui/layouts/settings/iq_panels.py

@@ -18,17 +18,17 @@ from openpilot.selfdrive.ui.layouts.settings.software import time_ago
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.system.hardware.hw import Paths
-from openpilot.system.ui.iqpilot.lib.styles import style
-from openpilot.system.ui.iqpilot.lib.utils import NoElideButtonAction
-from openpilot.system.ui.iqpilot.widgets.list_view import IQListItem, toggle_item
-from openpilot.system.ui.iqpilot.widgets.list_view import OptionControl
-from openpilot.system.ui.iqpilot.widgets.list_view import multiple_button_item, toggle_item
-from openpilot.system.ui.iqpilot.widgets.list_view import option_item, toggle_item, ToggleAction
-from openpilot.system.ui.iqpilot.widgets.list_view import progress_item
-from openpilot.system.ui.iqpilot.widgets.list_view import toggle_item, multiple_button_item, IQListItem, IQLineSeparator
-from openpilot.system.ui.iqpilot.widgets.list_view import toggle_item, option_item, IQLineSeparator
-from openpilot.system.ui.iqpilot.widgets.list_view import toggle_item, simple_button_item, option_item, IQLineSeparator
-from openpilot.system.ui.iqpilot.widgets.list_view import TreeFolder, TreeNode, TreeOptionDialog
+from openpilot.system.ui.iqwidgets.lib.styles import style
+from openpilot.system.ui.iqwidgets.lib.utils import WideButtonAction
+from openpilot.system.ui.iqwidgets.widgets.list_view import IQListItem, toggle_item
+from openpilot.system.ui.iqwidgets.widgets.list_view import OptionControl
+from openpilot.system.ui.iqwidgets.widgets.list_view import multiple_button_item, toggle_item
+from openpilot.system.ui.iqwidgets.widgets.list_view import option_item, toggle_item, ToggleAction
+from openpilot.system.ui.iqwidgets.widgets.list_view import progress_item
+from openpilot.system.ui.iqwidgets.widgets.list_view import toggle_item, multiple_button_item, IQListItem, IQLineSeparator
+from openpilot.system.ui.iqwidgets.widgets.list_view import toggle_item, option_item, IQLineSeparator
+from openpilot.system.ui.iqwidgets.widgets.list_view import toggle_item, simple_button_item, option_item, IQLineSeparator
+from openpilot.system.ui.iqwidgets.widgets.list_view import PickerGroup, PickerItem, PickerDialog
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.lib.multilang import tr, tr_noop
@@ -60,8 +60,8 @@ from openpilot.iqpilot.selfdrive.iqmodeld.models.runners.model_runner import CUS
 from openpilot.selfdrive.ui.layouts.settings import settings as OP
 from openpilot.selfdrive.ui.layouts.settings.toggles import TogglesLayout
 from openpilot.system.hardware import HARDWARE
-from openpilot.system.ui.iqpilot.lib.styles import metrics
-from openpilot.system.ui.iqpilot.widgets.list_view import (
+from openpilot.system.ui.iqwidgets.lib.styles import metrics
+from openpilot.system.ui.iqwidgets.widgets.list_view import (
   option_item as option_item,
   multiple_button_item as multiple_button_item,
   button_item as button_item,
@@ -69,11 +69,11 @@ from openpilot.system.ui.iqpilot.widgets.list_view import (
   NavSectionButton,
   Spacer,
 )
-from openpilot.system.ui.iqpilot.widgets.list_view import IQListItem
-from openpilot.system.ui.iqpilot.widgets.list_view import IQListItem, IQMultipleButtonAction, IQToggleAction, IQLineSeparator
-from openpilot.system.ui.iqpilot.widgets.list_view import button_item, toggle_item
-from openpilot.system.ui.iqpilot.widgets.list_view import NoticeModal
-from openpilot.system.ui.iqpilot.widgets.list_view import TreeOptionDialog, TreeNode, TreeFolder
+from openpilot.system.ui.iqwidgets.widgets.list_view import IQListItem
+from openpilot.system.ui.iqwidgets.widgets.list_view import IQListItem, IQMultipleButtonAction, IQToggleAction, IQLineSeparator
+from openpilot.system.ui.iqwidgets.widgets.list_view import button_item, toggle_item
+from openpilot.system.ui.iqwidgets.widgets.list_view import NoticeModal
+from openpilot.system.ui.iqwidgets.widgets.list_view import PickerDialog, PickerItem, PickerGroup
 from openpilot.system.ui.lib.application import gui_app, MousePos
 from openpilot.system.ui.lib.multilang import tr_noop
 from openpilot.system.ui.lib.text_measure import measure_text_cached
@@ -96,9 +96,9 @@ from iqdbc.car.hyundai.values import CAR, CANFD_UNSUPPORTED_LONGITUDINAL_CAR, UN
 from iqdbc.car.subaru.values import CAR, SubaruFlags
 from iqdbc.car.volkswagen.values import CAR, VolkswagenFlags
 from openpilot.common.basedir import BASEDIR
-from openpilot.system.ui.iqpilot.lib.styles import ink
-from openpilot.system.ui.iqpilot.widgets.list_view import multiple_button_item
-from openpilot.system.ui.iqpilot.widgets.list_view import toggle_item
+from openpilot.system.ui.iqwidgets.lib.styles import ink
+from openpilot.system.ui.iqwidgets.widgets.list_view import multiple_button_item
+from openpilot.system.ui.iqwidgets.widgets.list_view import toggle_item
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.widgets.list_view import ButtonAction
 import json
@@ -409,15 +409,15 @@ class IQMapsLayout(Widget):
          "take over the moment connectivity drops. Tiles come down with your selected region."),
       param="OfflineOSMaps",
     )
-    self._delete_maps_btn = IQListItem(tr("Downloaded Maps"), action_item=NoElideButtonAction(tr("DELETE"), enabled=True),
+    self._delete_maps_btn = IQListItem(tr("Downloaded Maps"), action_item=WideButtonAction(tr("DELETE"), enabled=True),
                                        callback=self._confirm_wipe)
     self._progress = progress_item(tr("Downloading Map"))
     self._tile_progress = progress_item(tr("Downloading Map Tiles"))
-    self._update_btn = IQListItem(tr("Database Update"), action_item=NoElideButtonAction(tr("CHECK"), enabled=True),
+    self._update_btn = IQListItem(tr("Database Update"), action_item=WideButtonAction(tr("CHECK"), enabled=True),
                                   callback=self._confirm_db_refresh)
-    self._country_btn = IQListItem(tr("Country"), action_item=NoElideButtonAction(tr("SELECT"), enabled=True),
+    self._country_btn = IQListItem(tr("Country"), action_item=WideButtonAction(tr("SELECT"), enabled=True),
                                    callback=lambda: self._open_region_picker("Country"))
-    self._state_btn = IQListItem(tr("State"), action_item=NoElideButtonAction(tr("SELECT"), enabled=True),
+    self._state_btn = IQListItem(tr("State"), action_item=WideButtonAction(tr("SELECT"), enabled=True),
                                  callback=lambda: self._open_region_picker("State"))
 
     self.items = [self._mapd_version, self._online_maps_toggle, self._offline_maps_toggle, self._delete_maps_btn,
@@ -483,7 +483,7 @@ class IQMapsLayout(Widget):
     url = _BOUNDS_BASE_URL + ("nation_bounding_boxes.json" if region_type == "Country" else "us_states_bounding_boxes.json")
     try:
       data = requests.get(url, timeout=10).json()
-      return sorted((TreeNode(ref=k, data={'display_name': v['full_name']}) for k, v in data.items()),
+      return sorted((PickerItem(ref=k, data={'display_name': v['full_name']}) for k, v in data.items()),
                     key=lambda n: n.data['display_name'])
     except Exception:
       return []
@@ -491,14 +491,14 @@ class IQMapsLayout(Widget):
   def _region_picker_worker(self, region_type, btn):
     locations = self._fetch_regions(region_type)
     if region_type == "State":
-      locations.insert(0, TreeNode(ref="All", data={'display_name': tr("All states (~6.0 GB)")}))
+      locations.insert(0, PickerItem(ref="All", data={'display_name': tr("All states (~6.0 GB)")}))
 
     btn.action_item.set_enabled(True)
     btn.action_item.set_text(tr("SELECT"))
 
     key = "OsmLocation" if region_type == "Country" else "OsmState"
     current = ui_state.params.get(f"{key}Name") or ""
-    dialog = TreeOptionDialog(tr(f"Select {region_type}"), [TreeFolder(folder="", nodes=locations)],
+    dialog = PickerDialog(tr(f"Select {region_type}"), [PickerGroup(folder="", nodes=locations)],
                               current_ref=current, search_prompt=tr("Perform a search"))
     done = lambda res: self._on_region_picked(region_type, locations, key, res, dialog.selection_ref)  # noqa: E731
     dialog.on_exit = done
@@ -1319,11 +1319,11 @@ class IQSoftwareLayout(SoftwareLayout):
 
     # single flat list: pinned branches first, then the rest alphabetically.
     # prebuilt ("-prebuilt") branches are internal build outputs, not user-selectable.
-    pinned_nodes = [TreeNode(b, {'display_name': b}) for b in top_level_branches if b in branches]
-    other_nodes = [TreeNode(b, {'display_name': b}) for b in sorted(branches)
+    pinned_nodes = [PickerItem(b, {'display_name': b}) for b in top_level_branches if b in branches]
+    other_nodes = [PickerItem(b, {'display_name': b}) for b in sorted(branches)
                    if b not in top_level_branches and not b.endswith("-prebuilt")]
 
-    folders = [TreeFolder("", pinned_nodes + other_nodes)]
+    folders = [PickerGroup("", pinned_nodes + other_nodes)]
 
     def _on_branch_selected(result):
       if result == DialogResult.CONFIRM and self._branch_dialog is not None:
@@ -1334,7 +1334,7 @@ class IQSoftwareLayout(SoftwareLayout):
           os.system("pkill -SIGUSR1 -f system.updated.updated")
       self._branch_dialog = None
 
-    self._branch_dialog = TreeOptionDialog(tr("Select a branch"), folders, current_target, "",
+    self._branch_dialog = PickerDialog(tr("Select a branch"), folders, current_target, "",
                                            on_exit=_on_branch_selected)
 
     gui_app.set_modal_overlay(self._branch_dialog, callback=_on_branch_selected)
@@ -1667,7 +1667,7 @@ class IQDeviceLayout(DeviceLayout):
 # ===== models =====
 
 if gui_app.iqpilot_ui():
-  from openpilot.system.ui.iqpilot.widgets.list_view import button_item as button_item
+  from openpilot.system.ui.iqwidgets.widgets.list_view import button_item as button_item
 
 _ACTIVE_BUNDLE_KEY = "ModelManager_ActiveBundle"
 _DOWNLOAD_INDEX_KEY = "ModelManager_DownloadIndex"
@@ -1694,7 +1694,7 @@ class ModelsLayout(Widget):
     self.current_model_item = IQListItem(
       title=tr("Current Model"),
       description="",
-      action_item=NoElideButtonAction(tr("SELECT")),
+      action_item=WideButtonAction(tr("SELECT")),
       callback=self._handle_current_model_clicked
     )
 
@@ -1707,7 +1707,7 @@ class ModelsLayout(Widget):
     self.clear_cache_item = IQListItem(
       title=tr("Clear Model Cache"),
       description="",
-      action_item=NoElideButtonAction(tr("CLEAR")),
+      action_item=WideButtonAction(tr("CLEAR")),
       callback=self._clear_cache
     )
 
@@ -1938,7 +1938,7 @@ class ModelsLayout(Widget):
 
   @staticmethod
   def _bundle_to_node(bundle):
-    return TreeNode(bundle.ref, {'display_name': bundle.displayName, 'short_name': bundle.internalName})
+    return PickerItem(bundle.ref, {'display_name': bundle.displayName, 'short_name': bundle.internalName})
 
   def _get_folders(self, favorites):
     bundles = self.model_manager.availableBundles
@@ -1946,14 +1946,14 @@ class ModelsLayout(Widget):
     for bundle in bundles:
       folders.setdefault(next((ov_ride.value for ov_ride in bundle.overrides if ov_ride.key == "folder"), ""), []).append(bundle)
 
-    folders_list = [TreeFolder("", [TreeNode("Default", {'display_name': tr("Default (CD210)"), 'short_name': "Default"})])]
+    folders_list = [PickerGroup("", [PickerItem("Default", {'display_name': tr("Default (CD210)"), 'short_name': "Default"})])]
     for folder, folder_bundles in sorted(folders.items(), key=lambda x: max((bundle.index for bundle in x[1]), default=-1), reverse=True):
       folder_bundles.sort(key=lambda bundle: bundle.index, reverse=True)
       name = folder + (f" - (Updated: {m.group(1)})" if folder_bundles and (m := re.search(r'\(([^)]*)\)[^(]*$', folder_bundles[0].displayName)) else "")
-      folders_list.append(TreeFolder(name, [self._bundle_to_node(bundle) for bundle in folder_bundles]))
+      folders_list.append(PickerGroup(name, [self._bundle_to_node(bundle) for bundle in folder_bundles]))
 
     if favorites and (fav_bundles := [bundle for bundle in bundles if bundle.ref in favorites]):
-      folders_list.insert(1, TreeFolder("Favorites", [self._bundle_to_node(bundle) for bundle in fav_bundles]))
+      folders_list.insert(1, PickerGroup("Favorites", [self._bundle_to_node(bundle) for bundle in fav_bundles]))
     return folders_list
 
   def _handle_current_model_clicked(self):
@@ -1962,7 +1962,7 @@ class ModelsLayout(Widget):
     folders_list = self._get_folders(favorites)
 
     active_ref = self.model_manager.activeBundle.ref if self._has_active_bundle_param() and self.model_manager.activeBundle else "Default"
-    self.model_dialog = TreeOptionDialog(tr("Select a Model"), folders_list, active_ref, "ModelManager_Favs",
+    self.model_dialog = PickerDialog(tr("Select a Model"), folders_list, active_ref, "ModelManager_Favs",
                                          get_folders_fn=self._get_folders, on_exit=self._on_model_selected)
     gui_app.set_modal_overlay(self.model_dialog, callback=self._on_model_selected)
 
@@ -2165,7 +2165,7 @@ class IQSettingsLayout(OP.SettingsLayout):
 
 # ===== vehicle_brands_base =====
 
-class BrandSettings:
+class BrandPanel:
   """Per-brand extra settings rows; brands without any simply don't register."""
 
   def __init__(self):
@@ -2184,7 +2184,7 @@ _TUNING_BLURBS = (
 )
 
 
-class HyundaiSettings(BrandSettings):
+class HyundaiSettings(BrandPanel):
   def __init__(self):
     super().__init__()
     self.alpha_long_available = False
@@ -2227,7 +2227,7 @@ class HyundaiSettings(BrandSettings):
 _UNSUPPORTED_FLAGS = SubaruFlags.GLOBAL_GEN2 | SubaruFlags.HYBRID
 
 
-class SubaruSettings(BrandSettings):
+class SubaruSettings(BrandPanel):
   def __init__(self):
     super().__init__()
     self._supported = False
@@ -2283,7 +2283,7 @@ def _speed_text(kmh: int) -> str:
   return f"{round(kmh * KM_TO_MILE)} mph"
 
 
-class TeslaSettings(BrandSettings):
+class TeslaSettings(BrandPanel):
   def __init__(self):
     super().__init__()
     self.coop_steering_toggle = toggle_item(tr("VTB (Virtual Torque Blending)"), "", param="TeslaCoopSteering")
@@ -2306,7 +2306,7 @@ class TeslaSettings(BrandSettings):
 
 # ===== vehicle_brands_toyota =====
 
-class ToyotaSettings(BrandSettings):
+class ToyotaSettings(BrandPanel):
   def __init__(self):
     super().__init__()
     self.enforce_stock_longitudinal = toggle_item(
@@ -2361,7 +2361,7 @@ DESCRIPTIONS = {
 }
 
 
-class VolkswagenSettings(BrandSettings):
+class VolkswagenSettings(BrandPanel):
   def __init__(self):
     super().__init__()
 
@@ -2445,7 +2445,7 @@ class VolkswagenSettings(BrandSettings):
 # ===== vehicle_brands_factory =====
 
 # Only brands that actually ship extra rows appear here; every other brand gets None.
-_REGISTRY: dict[str, type[BrandSettings]] = {
+_REGISTRY: dict[str, type[BrandPanel]] = {
   "hyundai": HyundaiSettings,
   "subaru": SubaruSettings,
   "tesla": TeslaSettings,
@@ -2454,12 +2454,12 @@ _REGISTRY: dict[str, type[BrandSettings]] = {
 }
 
 
-def brand_settings_for(brand: str) -> BrandSettings | None:
+def brand_settings_for(brand: str) -> BrandPanel | None:
   cls = _REGISTRY.get(brand)
   return cls() if cls else None
 
 
-class BrandSettingsFactory:
+class BrandPanelFactory:
   """Legacy shim for callers using the old factory name."""
 
   create_brand_settings = staticmethod(brand_settings_for)
@@ -2516,22 +2516,22 @@ class VehicleSelection:
   def clear():
     ui_state.params.remove("CarPlatformBundle")
 
-  def picker_folders(self) -> list[TreeFolder]:
-    def node_for(name: str) -> TreeNode:
+  def picker_folders(self) -> list[PickerGroup]:
+    def node_for(name: str) -> PickerItem:
       info = self.platforms[name]
       years = ' '.join(map(str, info.get('year', [])))
-      return TreeNode(name, {
+      return PickerItem(name, {
         'display_name': name,
         'search_tags': f"{name} {info.get('make')} {years} {info.get('model', name)}",
       })
 
     names = sorted(self.platforms)
     makes = sorted({self.platforms[n].get('make') for n in names})
-    return [TreeFolder(make, [node_for(n) for n in names if self.platforms[n].get('make') == make])
+    return [PickerGroup(make, [node_for(n) for n in names if self.platforms[n].get('make') == make])
             for make in makes]
 
 
-class PlatformSelector(Button):
+class VehiclePicker(Button):
   """Row button that either clears a forced platform or opens the vehicle picker."""
 
   def __init__(self, on_platform_change: Callable[[], None] | None = None):
@@ -2574,7 +2574,7 @@ class PlatformSelector(Button):
       self._open_picker()
 
   def _open_picker(self):
-    dialog = TreeOptionDialog(
+    dialog = PickerDialog(
       tr("Pick your vehicle"),
       self.selection.picker_folders(),
       search_prompt=tr("Search make or model"),
@@ -2609,7 +2609,7 @@ _LEGEND = (
 class LegendWidget(Widget):
   """Explains the fingerprint status colours; the active row is highlighted."""
 
-  def __init__(self, platform_selector: PlatformSelector):
+  def __init__(self, platform_selector: VehiclePicker):
     super().__init__()
     self.set_rect(rl.Rectangle(0, 0, 0, 350))
     self._selector = platform_selector
@@ -2650,7 +2650,7 @@ class VehicleLayout(Widget):
     super().__init__()
     self._brand_settings = None
     self._current_brand = None
-    self._platform_selector = PlatformSelector(self._on_vehicle_changed)
+    self._platform_selector = VehiclePicker(self._on_vehicle_changed)
     self._vehicle_item = IQListItem(title=self._platform_selector.text, action_item=ButtonAction(text=tr("SELECT")),
                                     callback=self._platform_selector._on_clicked)
     self._legend_widget = LegendWidget(self._platform_selector)

iqpilot/ui/mici/onroad/hud_renderer.py

@@ -4,7 +4,7 @@ Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed
 import pyray as rl
 
 from openpilot.selfdrive.ui.mici.onroad.hud_renderer import HudRenderer
-from openpilot.iqpilot.ui.onroad.hud_overlays import BlindSpotIndicators
+from openpilot.iqpilot.ui.onroad.hud_overlays import IQBlindSpotOverlay
 
 
 class IQMiciHudRenderer(HudRenderer):
@@ -16,7 +16,7 @@ class IQMiciHudRenderer(HudRenderer):
 
   def __init__(self):
     super().__init__()
-    self._overlays = [BlindSpotIndicators()]
+    self._overlays = [IQBlindSpotOverlay()]
 
   def _update_state(self) -> None:
     super()._update_state()

iqpilot/ui/onroad/driver_state.py

@@ -8,7 +8,7 @@ import pyray as rl
 from openpilot.common.params import Params
 from openpilot.selfdrive.ui import UI_BORDER_SIZE
 from openpilot.selfdrive.ui.onroad.driver_state import DriverStateRenderer, BTN_SIZE, ARC_LENGTH
-from openpilot.iqpilot.ui.onroad.hud_overlays import DeveloperUiRenderer
+from openpilot.iqpilot.ui.onroad.hud_overlays import IQDevMetricsOverlay
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 
@@ -50,7 +50,7 @@ class DriverStateRendererIQ(DriverStateRenderer):
     self._toast_color: rl.Color = rl.WHITE
     self._font = gui_app.font(FontWeight.SEMI_BOLD)
 
-    self.dev_ui_offset = DeveloperUiRenderer.get_bottom_dev_ui_offset()
+    self.dev_ui_offset = IQDevMetricsOverlay.get_bottom_dev_ui_offset()
     self._dm_background = gui_app.texture("icons_mici/onroad/driver_monitoring/dm_background.png", BTN_SIZE, BTN_SIZE)
     self._dm_person = gui_app.texture("icons_mici/onroad/driver_monitoring/dm_person.png", 118, 118)
     self._dm_cone = gui_app.texture("icons_mici/onroad/driver_monitoring/dm_cone.png", 118, 118)

iqpilot/ui/onroad/hud_overlays.py

@@ -22,7 +22,7 @@ from openpilot.selfdrive.ui.mici.onroad.alert_renderer import IconSide, TURN_SIG
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.iqpilot.lib import canvas
+from openpilot.system.ui.iqwidgets.lib import canvas
 from iqdbc.car.volkswagen.values import VolkswagenFlags
 
 
@@ -50,14 +50,19 @@ _STRIP_DECEL = (255, 0, 247)
 _STRIP_DECEL_NEON = (255, 145, 251)
 _STRIP_TIP_ALPHA = 235
 _STRIP_ROOT_ALPHA = 55
-# neon edge: opaque core inside the cap, then non-overlapping halo bands outside it
-_STRIP_CORE = 3.0
+_STRIP_CORE_DEPTH = 7.0
+_STRIP_CORE_LAYERS = 8
+_STRIP_CORE_ALPHA = 0.15
 _STRIP_CORE_FLOOR = 0.3
-_STRIP_HALO = ((3.0, 0.42), (5.0, 0.14))
+_STRIP_CORE_TAIL = 22.0
+_STRIP_HALO_SPREAD = 11.0
+_STRIP_HALO_LAYERS = 11
+_STRIP_HALO_ALPHA = 0.095
+_STRIP_HALO_TAIL = 34.0
 _STRIP_NEON_FULL = 2.0  # m/s^2 at which the edges reach full brightness
 
 
-class RocketFuel:
+class IQAccelBar:
   def __init__(self):
     self._eased = 0.0
 
@@ -70,16 +75,46 @@ class RocketFuel:
     return canvas.shade(*fill, int(_STRIP_TIP_ALPHA + (_STRIP_ROOT_ALPHA - _STRIP_TIP_ALPHA) * frac))
 
   @staticmethod
-  def _cap(center, cap: float, up: bool, fill, neon, heat: float) -> None:
+  def _halo(center, cap: float, up: bool, neon, heat: float, tail: float) -> None:
+    step = int(255 * _STRIP_HALO_ALPHA * heat)
+    if step < 1:
+      return
+    start, end = (180.0, 360.0) if up else (0.0, 180.0)
+    tint = canvas.shade(*neon, step)
+    faded = canvas.shade(*neon, 0)
+    top, bottom = (tint, faded) if up else (faded, tint)
+    for i in range(_STRIP_HALO_LAYERS):
+      spread = _STRIP_HALO_SPREAD * (1.0 - i / _STRIP_HALO_LAYERS)
+      if spread <= 0.0:
+        continue
+      canvas.annulus(center, cap, cap + spread, start, end, _STRIP_ARC_SEGMENTS, tint)
+      if tail <= 0.0:
+        continue
+      run = min(tail, _STRIP_HALO_TAIL)
+      y = center.y if up else center.y - run
+      canvas.v_sweep(center.x - cap - spread, y, spread, run, top, bottom)
+      canvas.v_sweep(center.x + cap, y, spread, run, top, bottom)
+
+  @staticmethod
+  def _cap(center, cap: float, up: bool, fill, neon, heat: float, tail: float) -> None:
     start, end = (180.0, 360.0) if up else (0.0, 180.0)
     canvas.annulus(center, 0.0, cap, start, end, _STRIP_ARC_SEGMENTS, fill)
-    edge = cap
-    for spread, weight in _STRIP_HALO:
-      canvas.annulus(center, edge, edge + spread, start, end, _STRIP_ARC_SEGMENTS,
-                     canvas.shade(*neon, int(255 * heat * weight)))
-      edge += spread
-    core = canvas.shade(*neon, int(255 * (_STRIP_CORE_FLOOR + (1.0 - _STRIP_CORE_FLOOR) * heat)))
-    canvas.annulus(center, max(0.0, cap - _STRIP_CORE), cap, start, end, _STRIP_ARC_SEGMENTS, core)
+    IQAccelBar._halo(center, cap, up, neon, heat, tail)
+    lit = _STRIP_CORE_FLOOR + (1.0 - _STRIP_CORE_FLOOR) * heat
+    core = canvas.shade(*neon, max(1, int(255 * _STRIP_CORE_ALPHA * lit)))
+    faded = canvas.shade(*neon, 0)
+    top, bottom = (core, faded) if up else (faded, core)
+    run = min(tail, _STRIP_CORE_TAIL)
+    for i in range(_STRIP_CORE_LAYERS):
+      depth = _STRIP_CORE_DEPTH * (1.0 - i / _STRIP_CORE_LAYERS)
+      if depth <= 0.0:
+        continue
+      canvas.annulus(center, max(0.0, cap - depth), cap, start, end, _STRIP_ARC_SEGMENTS, core)
+      if run <= 0.0:
+        continue
+      y = center.y if up else center.y - run
+      canvas.v_sweep(center.x - cap, y, depth, run, top, bottom)
+      canvas.v_sweep(center.x + cap - depth, y, depth, run, top, bottom)
 
   def render(self, rect, sm) -> None:
     if not ui_state.rocket_fuel:
@@ -100,8 +135,9 @@ class RocketFuel:
 
     canvas.v_sweep(x, top + cap, cap * 2.0, reach - cap * 2.0,
                    self._tint(fill, frac_top), self._tint(fill, frac_bottom))
-    self._cap(canvas.Pt(x + cap, top + cap), cap, True, self._tint(fill, frac_top), neon, heat)
-    self._cap(canvas.Pt(x + cap, top + reach - cap), cap, False, self._tint(fill, frac_bottom), neon, heat)
+    tail = max(0.0, reach / 2.0 - cap)
+    self._cap(canvas.Pt(x + cap, top + cap), cap, True, self._tint(fill, frac_top), neon, heat, tail)
+    self._cap(canvas.Pt(x + cap, top + reach - cap), cap, False, self._tint(fill, frac_bottom), neon, heat, tail)
 
 
 # ============================================================================
@@ -130,7 +166,7 @@ class _BlindSide:
     canvas.stamp(tex, x, rect.y + _BS_DROP, canvas.shade(255, 255, 255, int(255 * self.glow.x)))
 
 
-class BlindSpotIndicators:
+class IQBlindSpotOverlay:
   def __init__(self):
     self._left = _BlindSide("left")
     self._right = _BlindSide("right")
@@ -159,7 +195,7 @@ _MQB_CLUSTER_EXEMPT = (VolkswagenFlags.PQ | VolkswagenFlags.MLB | VolkswagenFlag
                        VolkswagenFlags.MEB_GEN2 | VolkswagenFlags.MQB_EVO)
 
 
-class SpeedRenderer:
+class IQSpeedOverlay:
   def __init__(self):
     self.speed: float = 0.0
     self._cluster_ever_live: bool = False
@@ -323,7 +359,7 @@ def _lamp_modes(event_name: str, cs, remembered):
   return left, right, None
 
 
-class TurnSignalController:
+class IQTurnSignalOverlay:
   def __init__(self, config: TurnSignalConfig | None = None):
     self._config = config or TurnSignalConfig()
     self._lamps = {IconSide.left: _IndicatorLamp(IconSide.left),
@@ -740,7 +776,7 @@ def _desired_probe(sm):
   return desired_lat_accel
 
 
-class DeveloperUiRenderer(Widget):
+class IQDevMetricsOverlay(Widget):
   DEV_UI_OFF = 0
   DEV_UI_RIGHT = 1
   DEV_UI_BOTTOM = 2
@@ -754,7 +790,7 @@ class DeveloperUiRenderer(Widget):
 
   @staticmethod
   def get_bottom_dev_ui_offset():
-    return DeveloperUiRenderer.BOTTOM_BAR_HEIGHT if ui_state.developer_ui != DeveloperUiRenderer.DEV_UI_OFF else 0
+    return IQDevMetricsOverlay.BOTTOM_BAR_HEIGHT if ui_state.developer_ui != IQDevMetricsOverlay.DEV_UI_OFF else 0
 
   def _update_state(self) -> None:
     self.dev_ui_mode = ui_state.developer_ui
@@ -813,7 +849,7 @@ def _dim(color, alpha: float):
   return canvas.with_opacity(color, 255 * alpha)
 
 
-class SpeedLimitRenderer(Widget):
+class IQSpeedLimitOverlay(Widget):
   """Regulatory sign, upcoming-limit preview and pre-active nudge arrows."""
 
   def __init__(self):

iqpilot/ui/onroad/hud_renderer.py

@@ -11,12 +11,12 @@ from openpilot.selfdrive.ui.mici.onroad.torque_bar import TorqueBar
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.selfdrive.ui.onroad.hud_renderer import HudRenderer
 from openpilot.iqpilot.ui.onroad.hud_overlays import (
-  DeveloperUiRenderer,
+  IQDevMetricsOverlay,
   RoadNameRenderer,
-  RocketFuel,
-  SpeedLimitRenderer,
-  TurnSignalController,
-  SpeedRenderer,
+  IQAccelBar,
+  IQSpeedLimitOverlay,
+  IQTurnSignalOverlay,
+  IQSpeedOverlay,
 )
 from openpilot.iqpilot.ui.onroad.nav_map_panel import NavMapPanel
 from openpilot.iqpilot.ui.onroad.soft_warning import SoftWarningRenderer
@@ -28,13 +28,13 @@ ENABLE_SPLIT_NAV_MAP_PANEL = True
 class IQHudRenderer(HudRenderer):
   def __init__(self):
     super().__init__()
-    self.developer_ui = DeveloperUiRenderer()
+    self.developer_ui = IQDevMetricsOverlay()
     self.nav_map_panel = NavMapPanel()
     self.road_name_renderer = RoadNameRenderer()
-    self.rocket_fuel = RocketFuel()
-    self.speed_limit_renderer = SpeedLimitRenderer()
-    self.turn_signal_controller = TurnSignalController()
-    self.speed_renderer = SpeedRenderer()
+    self.rocket_fuel = IQAccelBar()
+    self.speed_limit_renderer = IQSpeedLimitOverlay()
+    self.turn_signal_controller = IQTurnSignalOverlay()
+    self.speed_renderer = IQSpeedOverlay()
     self.soft_warning_renderer = SoftWarningRenderer()
     self._torque_bar = TorqueBar(scale=3.0, always=True)
 
@@ -59,8 +59,8 @@ class IQHudRenderer(HudRenderer):
 
     if ui_state.torque_bar:
       torque_rect = rect
-      if ui_state.developer_ui in (DeveloperUiRenderer.DEV_UI_BOTTOM, DeveloperUiRenderer.DEV_UI_BOTH):
-        torque_rect = rl.Rectangle(rect.x, rect.y, rect.width, rect.height - DeveloperUiRenderer.BOTTOM_BAR_HEIGHT)
+      if ui_state.developer_ui in (IQDevMetricsOverlay.DEV_UI_BOTTOM, IQDevMetricsOverlay.DEV_UI_BOTH):
+        torque_rect = rl.Rectangle(rect.x, rect.y, rect.width, rect.height - IQDevMetricsOverlay.BOTTOM_BAR_HEIGHT)
       self._torque_bar.render(torque_rect)
 
     if not self.split_nav_enabled():