Merge branch 'master' into navigationd-init

This reverts commit 3bbb33f6bd.

.github/workflows/tests.yaml

@@ -21,11 +21,12 @@ env:
   PYTHONWARNINGS: error
   BASE_IMAGE: sunnypilot-base
   AZURE_TOKEN: ${{ secrets.AZURE_COMMADATACI_OPENPILOTCI_TOKEN }}
+  MAPBOX_TOKEN_CI: ${{ secrets.MAPBOX_TOKEN_CI }}
 
   DOCKER_LOGIN: docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
   BUILD: release/ci/docker_build_sp.sh base
 
-  RUN: docker run --shm-size 2G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e CI=1 -e PYTHONWARNINGS=error -e FILEREADER_CACHE=1 -e PYTHONPATH=/tmp/openpilot -e NUM_JOBS -e JOB_ID -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e GITHUB_REPOSITORY -e GITHUB_RUN_ID -v $GITHUB_WORKSPACE/.ci_cache/scons_cache:/tmp/scons_cache -v $GITHUB_WORKSPACE/.ci_cache/comma_download_cache:/tmp/comma_download_cache -v $GITHUB_WORKSPACE/.ci_cache/openpilot_cache:/tmp/openpilot_cache $BASE_IMAGE /bin/bash -c
+  RUN: docker run --shm-size 2G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e CI=1 -e PYTHONWARNINGS=error -e FILEREADER_CACHE=1 -e PYTHONPATH=/tmp/openpilot -e NUM_JOBS -e JOB_ID -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e GITHUB_REPOSITORY -e GITHUB_RUN_ID -e MAPBOX_TOKEN_CI=$MAPBOX_TOKEN_CI -v $GITHUB_WORKSPACE/.ci_cache/scons_cache:/tmp/scons_cache -v $GITHUB_WORKSPACE/.ci_cache/comma_download_cache:/tmp/comma_download_cache -v $GITHUB_WORKSPACE/.ci_cache/openpilot_cache:/tmp/openpilot_cache $BASE_IMAGE /bin/bash -c
 
   PYTEST: pytest --continue-on-collection-errors --durations=0 -n logical
 

common/params_keys.h

@@ -189,6 +189,11 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ModelManager_LastSyncTime", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
     {"ModelManager_ModelsCache", {PERSISTENT | BACKUP, JSON}},
 
+    // Navigation params
+    {"MapboxToken", {PERSISTENT | BACKUP, STRING}},
+    {"MapboxSettings", {CLEAR_ON_MANAGER_START, JSON}},
+    {"MapboxRoute", {CLEAR_ON_MANAGER_START, STRING}},
+
     // Neural Network Lateral Control
     {"NeuralNetworkLateralControl", {PERSISTENT | BACKUP, BOOL, "0"}},
 

sunnypilot/navd/README.md

@@ -0,0 +1,5 @@
+# Navigation
+
+Navigation daemon with Mapbox integration for semi-offline navigation. This module handles route planning, geocoding, and turn-by-turn instructions to support autonomous driving features.
+
+- `navigation_helpers/`: Mapbox API integration and navigation instructions processing.

sunnypilot/navd/helpers.py

@@ -72,6 +72,15 @@ class Coordinate:
     return x * EARTH_MEAN_RADIUS
 
 
+def bearing_between_two_points(point_one: Coordinate, point_two: Coordinate) -> float:
+  dlon = math.radians(point_two.longitude - point_one.longitude)
+  bearing_radians = math.atan2(math.sin(dlon)* math.cos(point_two.latitude), math.cos(point_one.latitude) * math.sin(point_two.latitude) -
+                               math.sin(point_one.latitude) * math.cos(point_two.latitude) * math.cos(dlon))
+  bearing_degrees = math.degrees(bearing_radians)
+  bearing_normalized = (bearing_degrees + 360) % 360
+  return bearing_normalized
+
+
 def minimum_distance(a: Coordinate, b: Coordinate, p: Coordinate):
   if a.distance_to(b) < 0.01:
     return a.distance_to(p)
@@ -126,6 +135,8 @@ def string_to_direction(direction: str) -> str:
     if d in direction:
       if 'slight' in direction and d in MODIFIABLE_DIRECTIONS:
         return 'slight' + d.capitalize()
+      elif 'sharp' in direction and d in MODIFIABLE_DIRECTIONS:
+        return 'sharp' + d.capitalize()
       return d
   return 'none'
 

sunnypilot/navd/navigation_helpers/mapbox_integration.py

@@ -0,0 +1,113 @@
+"""
+Copyright (c) 2021-, James Vecellio, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import requests
+from urllib.parse import quote
+
+from openpilot.common.params import Params
+
+
+class MapboxIntegration:
+  def __init__(self):
+    self.params = Params()
+
+  def get_public_token(self) -> str:
+    token: str = self.params.get('MapboxToken', return_default=True)
+    return token
+
+  def set_destination(self, postvars, current_lon, current_lat, bearing=None) -> tuple[dict, bool]:
+    if 'latitude' in postvars and 'longitude' in postvars:
+      self.nav_confirmed(postvars, current_lon, current_lat, bearing)
+      return postvars, True
+
+    addr = postvars['place_name']
+    if not addr:
+      return postvars, False
+
+    token = self.get_public_token()
+    url = f'https://api.mapbox.com/geocoding/v5/mapbox.places/{quote(addr)}.json?access_token={token}&limit=1&proximity={current_lon},{current_lat}'
+    try:
+      response = requests.get(url, timeout=5)
+      if response.status_code == 200:
+        features = response.json()['features']
+        if features:
+          longitude, latitude = features[0]['geometry']['coordinates']
+          postvars.update({'latitude': latitude, 'longitude': longitude, 'name': addr})
+          self.nav_confirmed(postvars, current_lon, current_lat, bearing)
+          return postvars, True
+    except requests.RequestException:
+      pass  # Broad exception to handle network errors like no internet without crashing navd process.
+    return postvars, False
+
+  def nav_confirmed(self, postvars, start_lon, start_lat, bearing=None) -> None:
+    if not postvars:
+      return
+
+    latitude = float(postvars['latitude'])
+    longitude = float(postvars['longitude'])
+
+    data: dict = {'navData': {'current': {'latitude': latitude, 'longitude': longitude}, 'route': {}}}
+
+    token = self.get_public_token()
+    route_data = self.generate_route(start_lon, start_lat, longitude, latitude, token, bearing)
+    if route_data:
+      data['navData']['route'] = route_data
+    self.params.put('MapboxSettings', data)
+
+  @staticmethod
+  def generate_route(start_lon, start_lat, end_lon, end_lat, token, bearing=None) -> dict | None:
+    if not token:
+      return None
+
+    params = {
+      'access_token': token,
+      'geometries': 'geojson',
+      'steps': 'true',
+      'overview': 'full',
+      'annotations': 'maxspeed',
+      'alternatives': 'false',
+      'banner_instructions': 'true',
+    }
+    if bearing is not None:
+      params['bearings'] = f'{int((bearing + 360) % 360):.0f},90;'
+
+    try:
+      response = requests.get(f'https://api.mapbox.com/directions/v5/mapbox/driving/{start_lon},{start_lat};{end_lon},{end_lat}', params=params, timeout=5)
+      data = response.json() if response.status_code == 200 else {}
+    except requests.RequestException:
+      return None
+
+    routes = data['routes'] if data else None
+    legs = routes[0]['legs'] if routes else None
+
+    if data.get('code') != 'Ok' or not routes or not legs:
+      return None
+
+    route = routes[0]
+    leg = legs[0]
+
+    steps = [
+      {
+        'maneuver': step['maneuver']['type'],
+        'instruction': step['maneuver']['instruction'],
+        'distance': step['distance'],
+        'duration': step['duration'],
+        'location': {'longitude': step['maneuver']['location'][0], 'latitude': step['maneuver']['location'][1]},
+        'modifier': step['maneuver'].get('modifier', 'none'),
+        'bannerInstructions': step['bannerInstructions'],
+      }
+      for step in leg['steps']
+    ]
+
+    maxspeed = [{'speed': item['speed'], 'unit': item['unit']} for item in leg['annotation']['maxspeed'] if 'speed' in item]
+
+    return {
+      'steps': steps,
+      'totalDistance': route['distance'],
+      'totalDuration': route['duration'],
+      'geometry': [{'longitude': coord[0], 'latitude': coord[1]} for coord in route['geometry']['coordinates']],
+      'maxspeed': maxspeed,
+    }

sunnypilot/navd/navigation_helpers/nav_instructions.py

@@ -0,0 +1,152 @@
+"""
+Copyright (c) 2021-, James Vecellio, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from numpy import interp
+
+from openpilot.common.params import Params
+
+from openpilot.sunnypilot.navd.helpers import Coordinate, bearing_between_two_points, distance_along_geometry, string_to_direction
+
+
+class NavigationInstructions:
+  def __init__(self):
+    self.coord = Coordinate(0, 0)
+    self.params = Params()
+
+    self._cached_route = None
+    self._route_loaded = False
+    self._no_route = False
+
+    self.closest_idx: float = 0
+
+  def get_route_progress(self, current_lat, current_lon) -> dict | None:
+    route = self.get_current_route()
+    if not route or not route['geometry'] or not route['steps']:
+      return None
+
+    self.coord.latitude = current_lat
+    self.coord.longitude = current_lon
+
+    # Find the closest point on the route relative to self
+    self.closest_idx, min_distance = min(((idx, self.coord.distance_to(coord)) for idx, coord in enumerate(route['geometry'])), key=lambda x: x[1])
+    closest_cumulative = distance_along_geometry(route['geometry'], self.coord)
+
+    # Find the current step index, which is the HIGHEST idx where the step location cumulative less/equal closest cumulative
+    current_step_idx = max((idx for idx, step in enumerate(route['steps']) if step['cumulative_distance'] <= closest_cumulative), default=-1)
+    current_step = route['steps'][current_step_idx if current_step_idx >= 0 else 0]
+
+    # The next turn is the next step relative to our cumulative index
+    next_turn_idx = current_step_idx + 1
+    next_turn = route['steps'][next_turn_idx] if 0 <= next_turn_idx < len(route['steps']) else None
+
+    current_maxspeed = current_step['maxspeed']
+
+    distance_to_end_of_step = max(0, current_step['distance'] - (closest_cumulative - current_step['cumulative_distance']))
+
+    all_maneuvers: list = []
+    max_maneuvers = 3
+    for idx in range(current_step_idx, min(current_step_idx + max_maneuvers, len(route['steps']))):
+      step = route['steps'][idx]
+      if idx == current_step_idx:
+        distance = distance_to_end_of_step
+      else:
+        distance = step['cumulative_distance'] - closest_cumulative
+      all_maneuvers.append({'distance': distance, 'type': step['maneuver'], 'modifier': step['modifier'], 'instruction': step['instruction']})
+
+    return {
+      'distance_from_route': min_distance,
+      'current_step': current_step,
+      'next_turn': next_turn,
+      'current_maxspeed': current_maxspeed,
+      'all_maneuvers': all_maneuvers,
+      'current_step_idx': current_step_idx,
+      'distance_to_end_of_step': distance_to_end_of_step,
+    }
+
+  def get_current_route(self):
+    if self._route_loaded and self._cached_route is not None:
+      return self._cached_route
+    if self._no_route:
+      return None
+
+    param_value = self.params.get('MapboxSettings')
+    route = param_value['navData']['route'] if param_value else None
+    if not route:
+      self._no_route = True
+      return None
+
+    geometry = [Coordinate(coord['latitude'], coord['longitude']) for coord in route['geometry']]
+    cumulative_distances = [0.0]
+    cumulative_distances.extend(cumulative_distances[-1] + geometry[step - 1].distance_to(geometry[step]) for step in range(1, len(geometry)))
+    maxspeed = [(speed['speed'], speed['unit']) for speed in route['maxspeed']]
+    steps = []
+    for step in route['steps']:
+      location = Coordinate(step['location']['latitude'], step['location']['longitude'])
+      closest_idx = min(range(len(geometry)), key=lambda i: location.distance_to(geometry[i]))
+      steps.append({
+        'bannerInstructions': step['bannerInstructions'],
+        'distance': step['distance'],
+        'duration': step['duration'],
+        'maneuver': step['maneuver'],
+        'location': location,
+        'cumulative_distance': cumulative_distances[closest_idx],
+        'maxspeed': maxspeed[min(closest_idx, len(maxspeed) - 1)] if len(maxspeed) > 0 else (0, 'kmh'),
+        'modifier': string_to_direction(step['modifier']),
+        'instruction': step['instruction'],
+      })
+    self._cached_route = {
+      'bearings': [bearing_between_two_points(geometry[i], geometry[i+2]) for i in range(len(geometry)-2)],
+      'steps': steps,
+      'total_distance': route['totalDistance'],
+      'total_duration': route['totalDuration'],
+      'geometry': geometry,
+      'cumulative_distances': cumulative_distances,
+      'maxspeed': maxspeed,
+    }
+    self._route_loaded = True
+    return self._cached_route
+
+  def clear_route_cache(self):
+    self._cached_route = None
+    self._route_loaded = False
+    self._no_route = False
+
+  def route_bearing_misalign(self, route, bearing, v_ego) -> bool:
+    route_bearing_misalign:bool = False
+
+    if v_ego < 5.0:
+      route_bearing_misalign = False
+    elif 0 < self.closest_idx < len(route['geometry']) -1:
+      route_bearing = route['bearings'][self.closest_idx -1]
+      current_bearing_normalized = (bearing + 360) % 360
+      bearing_difference = abs(current_bearing_normalized - route_bearing)
+
+      if min(bearing_difference, 360 - bearing_difference) > 95:
+        route_bearing_misalign = True  # flag for recompute/cancellation
+    return route_bearing_misalign
+
+  def get_upcoming_turn_from_progress(self, progress, current_lat, current_lon, v_ego: float) -> str:
+    if progress and progress['next_turn']:
+      speed_breakpoints: list = [0, 5, 10, 15, 20, 25, 30, 35, 40]
+      distance_breakpoints: list = [20, 25, 30, 45, 60, 75, 90, 105, 120]
+      distance_interp = interp(v_ego, speed_breakpoints, distance_breakpoints)
+
+      self.coord.latitude = current_lat
+      self.coord.longitude = current_lon
+      distance = self.coord.distance_to(progress['next_turn']['location'])
+
+      if distance <= distance_interp:
+        modifier = progress['next_turn']['modifier']
+        return str(modifier)
+    return 'none'
+
+  @staticmethod
+  def arrived_at_destination(progress, v_ego) -> bool:
+    if v_ego < 1.0:
+      maneuvers = progress['all_maneuvers'][0]
+      if maneuvers['type'] == 'arrive' or maneuvers['instruction'].startswith('Your destination'):
+        return True
+    return False

sunnypilot/navd/navigation_helpers/tests/test_mapbox.py

@@ -0,0 +1,98 @@
+"""
+Copyright (c) 2021-, James Vecellio, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import os
+
+from openpilot.common.constants import CV
+
+from openpilot.sunnypilot.navd.navigation_helpers.mapbox_integration import MapboxIntegration
+from openpilot.sunnypilot.navd.navigation_helpers.nav_instructions import NavigationInstructions
+
+
+class TestMapbox:
+  @classmethod
+  def setup_class(cls):
+    cls.mapbox = MapboxIntegration()
+    cls.nav = NavigationInstructions()
+
+    token = os.environ.get('MAPBOX_TOKEN_CI')
+    if token:
+      cls.mapbox.params.put('MapboxToken', token)
+
+    # route setup
+    cls.current_lon, cls.current_lat = -119.17557, 34.23305
+    cls.mapbox.params.put('MapboxRoute', '740 E Ventura Blvd. Camarillo, CA')
+    cls.postvars = {"place_name": cls.mapbox.params.get('MapboxRoute')}
+    cls.postvars, cls.valid_addr = cls.mapbox.set_destination(cls.postvars, cls.current_lon, cls.current_lat)
+    cls.route = cls.nav.get_current_route()
+    cls.progress = cls.nav.get_route_progress(cls.current_lat, cls.current_lon)
+
+  def test_set_destination(self):
+    assert self.valid_addr
+    settings = self.mapbox.params.get('MapboxSettings')
+    assert settings is not None
+    dest_lat = settings['navData']['current']['latitude']
+    dest_lon = settings['navData']['current']['longitude']
+    assert dest_lat == self.postvars["latitude"] and dest_lon == self.postvars["longitude"]
+
+  def test_get_route(self):
+    assert self.route is not None
+    assert 'steps' in self.route
+    assert 'geometry' in self.route
+    assert 'maxspeed' in self.route
+    assert 'total_distance' in self.route
+    assert 'total_duration' in self.route
+    assert len(self.route['steps']) > 0
+    assert len(self.route['geometry']) > 0
+    assert len(self.route['maxspeed']) > 0
+
+    if self.route and 'steps' in self.route:
+      for step in self.route['steps']:
+        assert 'modifier' in step
+
+  def test_upcoming_turn_detection(self):
+    upcoming = self.nav.get_upcoming_turn_from_progress(self.progress, self.current_lat, self.current_lon, v_ego=40.0)
+    assert isinstance(upcoming, str)
+    assert upcoming == 'none'
+
+    if self.route['steps']:
+      turn_lat = self.route['steps'][1]['location'].latitude
+      turn_lon = self.route['steps'][1]['location'].longitude
+      close_lat = turn_lat - 0.000175  # slightly before the turn
+      if self.progress and self.progress.get('next_turn'):
+        expected_turn = self.progress['next_turn']['modifier']
+        upcoming_close = self.nav.get_upcoming_turn_from_progress(self.progress, close_lat, turn_lon, v_ego=0.0)
+        if expected_turn:
+          assert upcoming_close == expected_turn == 'right', "Should be a right turn upcoming"
+
+  def test_route_progress_tracking(self):
+    assert self.progress is not None
+    assert 'distance_from_route' in self.progress
+    assert 'next_turn' in self.progress
+    assert 'current_maxspeed' in self.progress
+    assert 'all_maneuvers' in self.progress
+    assert 'distance_to_end_of_step' in self.progress
+    assert self.progress['distance_from_route'] >= 0
+    assert isinstance(self.progress['all_maneuvers'], list)
+
+  def test_speed_limit_handling(self):
+    speed_limit_metric = self.progress['current_maxspeed'][0]
+    speed_limit_imperial = (round(speed_limit_metric * CV.KPH_TO_MPH))
+    assert isinstance(speed_limit_metric, int)
+    assert isinstance(speed_limit_imperial, int)
+
+  def test_arrival_detection(self):
+    is_arrived = self.nav.arrived_at_destination(self.progress, 2.0)
+    assert isinstance(is_arrived, bool)
+    assert not is_arrived
+
+  def test_bearing_misalign(self):
+    lat = self.route['steps'][1]['location'].latitude
+    lon = self.route['steps'][1]['location'].longitude
+    self.nav.get_route_progress(lat, lon)
+    route_bearing_misaligned = self.nav.route_bearing_misalign(self.route, 45, 5.0)
+    # based on math: closest index: 7, normalized bearing: 45 route bearing: 180.5486953778888, expected differential: 135.54869538
+    assert route_bearing_misaligned