map: Transfer to MapLibre

SConstruct

@@ -145,7 +145,7 @@ else:
     libpath = [
       f"#third_party/acados/{arch}/lib",
       f"#third_party/libyuv/{arch}/lib",
-      f"#third_party/mapbox-gl-native-qt/{arch}",
+      f"#third_party/maplibre-native-qt/{arch}/lib",
       "/usr/lib",
       "/usr/local/lib",
     ]
@@ -208,11 +208,12 @@ env = Environment(
     "#third_party/json11",
     "#third_party/linux/include",
     "#third_party/snpe/include",
-    "#third_party/mapbox-gl-native-qt/include",
     "#third_party/qrcode",
     "#third_party",
     "#cereal",
     "#opendbc/can",
+    "#third_party/maplibre-native-qt/include",
+    f"#third_party/maplibre-native-qt/{arch}/include"
   ],
 
   CC='clang',

selfdrive/navd/SConscript

@@ -1,14 +1,14 @@
 Import('qt_env', 'arch', 'common', 'messaging', 'visionipc', 'cereal', 'transformations')
 
 map_env = qt_env.Clone()
-libs = ['qt_widgets', 'qt_util', 'qmapboxgl', common, messaging, cereal, visionipc, transformations,
+libs = ['qt_widgets', 'qt_util', 'QMapLibre', common, messaging, cereal, visionipc, transformations,
         'zmq', 'capnp', 'kj', 'm', 'OpenCL', 'ssl', 'crypto', 'pthread', 'json11'] + map_env["LIBS"]
 if arch == 'larch64':
   libs.append(':libEGL_mesa.so.0')
 
 if arch in ['larch64', 'aarch64', 'x86_64']:
   if arch == 'x86_64':
-    rpath = Dir(f"#third_party/mapbox-gl-native-qt/{arch}").srcnode().abspath
+    rpath = Dir(f"#third_party/maplibre-native-qt/{arch}/lib").srcnode().abspath
     map_env["RPATH"] += [rpath, ]
 
   style_path = File("style.json").abspath

selfdrive/navd/map_renderer.cc

@@ -28,16 +28,16 @@ float get_zoom_level_for_scale(float lat, float meters_per_pixel) {
   return log2(num_tiles) - 1;
 }
 
-QMapbox::Coordinate get_point_along_line(float lat, float lon, float bearing, float dist) {
+QMapLibre::Coordinate get_point_along_line(float lat, float lon, float bearing, float dist) {
   float ang_dist = dist / EARTH_RADIUS_METERS;
   float lat1 = DEG2RAD(lat), lon1 = DEG2RAD(lon), bearing1 = DEG2RAD(bearing);
   float lat2 = asin(sin(lat1)*cos(ang_dist) + cos(lat1)*sin(ang_dist)*cos(bearing1));
   float lon2 = lon1 + atan2(sin(bearing1)*sin(ang_dist)*cos(lat1), cos(ang_dist)-sin(lat1)*sin(lat2));
-  return QMapbox::Coordinate(RAD2DEG(lat2), RAD2DEG(lon2));
+  return QMapLibre::Coordinate(RAD2DEG(lat2), RAD2DEG(lon2));
 }
 
 
-MapRenderer::MapRenderer(const QMapboxGLSettings &settings, bool online) : m_settings(settings) {
+MapRenderer::MapRenderer(const QMapLibre::Settings &settings, bool online) : m_settings(settings) {
   QSurfaceFormat fmt;
   fmt.setRenderableType(QSurfaceFormat::OpenGLES);
 
@@ -60,8 +60,8 @@ MapRenderer::MapRenderer(const QMapboxGLSettings &settings, bool online) : m_set
   fbo.reset(new QOpenGLFramebufferObject(WIDTH, HEIGHT, fbo_format));
 
   std::string style = util::read_file(STYLE_PATH);
-  m_map.reset(new QMapboxGL(nullptr, m_settings, fbo->size(), 1));
-  m_map->setCoordinateZoom(QMapbox::Coordinate(0, 0), DEFAULT_ZOOM);
+  m_map.reset(new QMapLibre::Map(nullptr, m_settings, fbo->size(), 1));
+  m_map->setCoordinateZoom(QMapLibre::Coordinate(0, 0), DEFAULT_ZOOM);
   m_map->setStyleJson(style.c_str());
   m_map->createRenderer();
   ever_loaded = false;
@@ -70,20 +70,20 @@ MapRenderer::MapRenderer(const QMapboxGLSettings &settings, bool online) : m_set
   m_map->setFramebufferObject(fbo->handle(), fbo->size());
   gl_functions->glViewport(0, 0, WIDTH, HEIGHT);
 
-  QObject::connect(m_map.data(), &QMapboxGL::mapChanged, [=](QMapboxGL::MapChange change) {
+  QObject::connect(m_map.data(), &QMapLibre::Map::mapChanged, [=](QMapLibre::Map::MapChange change) {
     // Ignore expected signals
     // https://github.com/mapbox/mapbox-gl-native/blob/cf734a2fec960025350d8de0d01ad38aeae155a0/platform/qt/include/qmapboxgl.hpp#L116
     if (ever_loaded) {
-      if (change != QMapboxGL::MapChange::MapChangeRegionWillChange &&
-          change != QMapboxGL::MapChange::MapChangeRegionDidChange &&
-          change != QMapboxGL::MapChange::MapChangeWillStartRenderingFrame &&
-          change != QMapboxGL::MapChange::MapChangeDidFinishRenderingFrameFullyRendered) {
+      if (change != QMapLibre::Map::MapChange::MapChangeRegionWillChange &&
+          change != QMapLibre::Map::MapChange::MapChangeRegionDidChange &&
+          change != QMapLibre::Map::MapChange::MapChangeWillStartRenderingFrame &&
+          change != QMapLibre::Map::MapChange::MapChangeDidFinishRenderingFrameFullyRendered) {
         LOGD("New map state: %d", change);
       }
     }
   });
 
-  QObject::connect(m_map.data(), &QMapboxGL::mapLoadingFailed, [=](QMapboxGL::MapLoadingFailure err_code, const QString &reason) {
+  QObject::connect(m_map.data(), &QMapLibre::Map::mapLoadingFailed, [=](QMapLibre::Map::MapLoadingFailure err_code, const QString &reason) {
     LOGE("Map loading failed with %d: '%s'\n", err_code, reason.toStdString().c_str());
   });
 
@@ -145,7 +145,7 @@ void MapRenderer::msgUpdate() {
   timer->start(0);
 }
 
-void MapRenderer::updatePosition(QMapbox::Coordinate position, float bearing) {
+void MapRenderer::updatePosition(QMapLibre::Coordinate position, float bearing) {
   if (m_map.isNull()) {
     return;
   }
@@ -261,10 +261,10 @@ void MapRenderer::updateRoute(QList<QGeoCoordinate> coordinates) {
   initLayers();
 
   auto route_points = coordinate_list_to_collection(coordinates);
-  QMapbox::Feature feature(QMapbox::Feature::LineStringType, route_points, {}, {});
+  QMapLibre::Feature feature(QMapLibre::Feature::LineStringType, route_points, {}, {});
   QVariantMap navSource;
   navSource["type"] = "geojson";
-  navSource["data"] = QVariant::fromValue<QMapbox::Feature>(feature);
+  navSource["data"] = QVariant::fromValue<QMapLibre::Feature>(feature);
   m_map->updateSource("navSource", navSource);
   m_map->setLayoutProperty("navLayer", "visibility", "visible");
 }
@@ -273,10 +273,9 @@ void MapRenderer::initLayers() {
   if (!m_map->layerExists("navLayer")) {
     LOGD("Initializing navLayer");
     QVariantMap nav;
-    nav["id"] = "navLayer";
     nav["type"] = "line";
     nav["source"] = "navSource";
-    m_map->addLayer(nav, "road-intersection");
+    m_map->addLayer("navLayer", nav, "road-intersection");
     m_map->setPaintProperty("navLayer", "line-color", QColor("grey"));
     m_map->setPaintProperty("navLayer", "line-width", 5);
     m_map->setLayoutProperty("navLayer", "line-cap", "round");
@@ -296,9 +295,10 @@ extern "C" {
     QApplication *app = new QApplication(argc, argv);
     assert(app);
 
-    QMapboxGLSettings settings;
+    QMapLibre::Settings settings;
+    settings.setProviderTemplate(QMapLibre::Settings::ProviderTemplate::MapboxProvider);
     settings.setApiBaseUrl(maps_host == nullptr ? MAPS_HOST : maps_host);
-    settings.setAccessToken(token == nullptr ? get_mapbox_token() : token);
+    settings.setApiKey(token == nullptr ? get_mapbox_token() : token);
 
     return new MapRenderer(settings, false);
   }

selfdrive/navd/map_renderer.h

@@ -3,7 +3,8 @@
 #include <memory>
 
 #include <QOpenGLContext>
-#include <QMapboxGL>
+#include <QMapLibre/Map>
+#include <QMapLibre/Settings>
 #include <QTimer>
 #include <QGeoCoordinate>
 #include <QOpenGLBuffer>
@@ -19,7 +20,7 @@ class MapRenderer : public QObject {
   Q_OBJECT
 
 public:
-  MapRenderer(const QMapboxGLSettings &, bool online=true);
+  MapRenderer(const QMapLibre::Settings &, bool online=true);
   uint8_t* getImage();
   void update();
   bool loaded();
@@ -37,8 +38,8 @@ class MapRenderer : public QObject {
   void publish(const double render_time, const bool loaded);
   void sendThumbnail(const uint64_t ts, const kj::Array<capnp::byte> &buf);
 
-  QMapboxGLSettings m_settings;
-  QScopedPointer<QMapboxGL> m_map;
+  QMapLibre::Settings m_settings;
+  QScopedPointer<QMapLibre::Map> m_map;
 
   void initLayers();
 
@@ -52,7 +53,7 @@ class MapRenderer : public QObject {
   bool ever_loaded = false;
 
 public slots:
-  void updatePosition(QMapbox::Coordinate position, float bearing);
+  void updatePosition(QMapLibre::Coordinate position, float bearing);
   void updateRoute(QList<QGeoCoordinate> coordinates);
   void msgUpdate();
 };

selfdrive/ui/SConscript

@@ -12,7 +12,7 @@ if arch == 'larch64':
 maps = arch in ['larch64', 'aarch64', 'x86_64']
 
 if maps and arch != 'larch64':
-  rpath = [Dir(f"#third_party/mapbox-gl-native-qt/{arch}").srcnode().abspath]
+  rpath = [Dir(f"#third_party/maplibre-native-qt/{arch}/lib").srcnode().abspath]
   qt_env["RPATH"] += rpath
 
 if arch == "Darwin":
@@ -31,7 +31,7 @@ widgets_src = ["ui.cc", "qt/widgets/input.cc", "qt/widgets/wifi.cc",
 
 qt_env['CPPDEFINES'] = []
 if maps:
-  base_libs += ['qmapboxgl']
+  base_libs += ['QMapLibre']
   widgets_src += ["qt/maps/map_helpers.cc", "qt/maps/map_settings.cc", "qt/maps/map.cc", "qt/maps/map_panel.cc",
                   "qt/maps/map_eta.cc", "qt/maps/map_instructions.cc"]
   qt_env['CPPDEFINES'] += ["ENABLE_MAPS"]

selfdrive/ui/qt/maps/map.cc

@@ -18,7 +18,7 @@ const float MAX_PITCH = 50;
 const float MIN_PITCH = 0;
 const float MAP_SCALE = 2;
 
-MapWindow::MapWindow(const QMapboxGLSettings &settings) : m_settings(settings), velocity_filter(0, 10, 0.05, false) {
+MapWindow::MapWindow(const QMapLibre::Settings &settings) : m_settings(settings), velocity_filter(0, 10, 0.05, false) {
   QObject::connect(uiState(), &UIState::uiUpdate, this, &MapWindow::updateState);
 
   map_overlay = new QWidget (this);
@@ -57,21 +57,20 @@ void MapWindow::initLayers() {
   if (!m_map->layerExists("modelPathLayer")) {
     qDebug() << "Initializing modelPathLayer";
     QVariantMap modelPath;
-    modelPath["id"] = "modelPathLayer";
+    //modelPath["id"] = "modelPathLayer";
     modelPath["type"] = "line";
     modelPath["source"] = "modelPathSource";
-    m_map->addLayer(modelPath);
+    m_map->addLayer("modelPathLayer", modelPath);
     m_map->setPaintProperty("modelPathLayer", "line-color", QColor("red"));
     m_map->setPaintProperty("modelPathLayer", "line-width", 5.0);
     m_map->setLayoutProperty("modelPathLayer", "line-cap", "round");
   }
   if (!m_map->layerExists("navLayer")) {
     qDebug() << "Initializing navLayer";
     QVariantMap nav;
-    nav["id"] = "navLayer";
     nav["type"] = "line";
     nav["source"] = "navSource";
-    m_map->addLayer(nav, "road-intersection");
+    m_map->addLayer("navLayer", nav, "road-intersection");
 
     QVariantMap transition;
     transition["duration"] = 400;  // ms
@@ -84,10 +83,9 @@ void MapWindow::initLayers() {
     qDebug() << "Initializing pinLayer";
     m_map->addImage("default_marker", QImage("../assets/navigation/default_marker.svg"));
     QVariantMap pin;
-    pin["id"] = "pinLayer";
     pin["type"] = "symbol";
     pin["source"] = "pinSource";
-    m_map->addLayer(pin);
+    m_map->addLayer("pinLayer", pin);
     m_map->setLayoutProperty("pinLayer", "icon-pitch-alignment", "viewport");
     m_map->setLayoutProperty("pinLayer", "icon-image", "default_marker");
     m_map->setLayoutProperty("pinLayer", "icon-ignore-placement", true);
@@ -100,10 +98,9 @@ void MapWindow::initLayers() {
     m_map->addImage("label-arrow", QImage("../assets/images/triangle.svg"));
 
     QVariantMap carPos;
-    carPos["id"] = "carPosLayer";
     carPos["type"] = "symbol";
     carPos["source"] = "carPosSource";
-    m_map->addLayer(carPos);
+    m_map->addLayer("carPosLayer", carPos);
     m_map->setLayoutProperty("carPosLayer", "icon-pitch-alignment", "map");
     m_map->setLayoutProperty("carPosLayer", "icon-image", "label-arrow");
     m_map->setLayoutProperty("carPosLayer", "icon-size", 0.5);
@@ -149,7 +146,7 @@ void MapWindow::updateState(const UIState &s) {
     locationd_valid = (locationd_pos.getValid() && locationd_orientation.getValid() && locationd_velocity.getValid() && pos_accurate_enough);
 
     if (locationd_valid) {
-      last_position = QMapbox::Coordinate(locationd_pos.getValue()[0], locationd_pos.getValue()[1]);
+      last_position = QMapLibre::Coordinate(locationd_pos.getValue()[0], locationd_pos.getValue()[1]);
       last_bearing = RAD2DEG(locationd_orientation.getValue()[2]);
       velocity_filter.update(std::max(10.0, locationd_velocity.getValue()[0]));
     }
@@ -186,10 +183,10 @@ void MapWindow::updateState(const UIState &s) {
   if (locationd_valid) {
     // Update current location marker
     auto point = coordinate_to_collection(*last_position);
-    QMapbox::Feature feature1(QMapbox::Feature::PointType, point, {}, {});
+    QMapLibre::Feature feature1(QMapLibre::Feature::PointType, point, {}, {});
     QVariantMap carPosSource;
     carPosSource["type"] = "geojson";
-    carPosSource["data"] = QVariant::fromValue<QMapbox::Feature>(feature1);
+    carPosSource["data"] = QVariant::fromValue<QMapLibre::Feature>(feature1);
     m_map->updateSource("carPosSource", carPosSource);
 
     // Map bearing isn't updated when interacting, keep location marker up to date
@@ -230,10 +227,10 @@ void MapWindow::updateState(const UIState &s) {
     qWarning() << "Updating navLayer with new route";
     auto route = sm["navRoute"].getNavRoute();
     auto route_points = capnp_coordinate_list_to_collection(route.getCoordinates());
-    QMapbox::Feature feature(QMapbox::Feature::LineStringType, route_points, {}, {});
+    QMapLibre::Feature feature(QMapLibre::Feature::LineStringType, route_points, {}, {});
     QVariantMap navSource;
     navSource["type"] = "geojson";
-    navSource["data"] = QVariant::fromValue<QMapbox::Feature>(feature);
+    navSource["data"] = QVariant::fromValue<QMapLibre::Feature>(feature);
     m_map->updateSource("navSource", navSource);
     m_map->setLayoutProperty("navLayer", "visibility", "visible");
 
@@ -256,24 +253,24 @@ void MapWindow::resizeGL(int w, int h) {
 }
 
 void MapWindow::initializeGL() {
-  m_map.reset(new QMapboxGL(this, m_settings, size(), 1));
+  m_map.reset(new QMapLibre::Map(this, m_settings, size(), 1));
 
   if (last_position) {
     m_map->setCoordinateZoom(*last_position, MAX_ZOOM);
   } else {
-    m_map->setCoordinateZoom(QMapbox::Coordinate(64.31990695292795, -149.79038934046247), MIN_ZOOM);
+    m_map->setCoordinateZoom(QMapLibre::Coordinate(64.31990695292795, -149.79038934046247), MIN_ZOOM);
   }
 
   m_map->setMargins({0, 350, 0, 50});
   m_map->setPitch(MIN_PITCH);
   m_map->setStyleUrl("mapbox://styles/commaai/clkqztk0f00ou01qyhsa5bzpj");
 
-  QObject::connect(m_map.data(), &QMapboxGL::mapChanged, [=](QMapboxGL::MapChange change) {
+  QObject::connect(m_map.data(), &QMapLibre::Map::mapChanged, [=](QMapLibre::Map::MapChange change) {
     // set global animation duration to 0 ms so visibility changes are instant
-    if (change == QMapboxGL::MapChange::MapChangeDidFinishLoadingStyle) {
+    if (change == QMapLibre::Map::MapChange::MapChangeDidFinishLoadingStyle) {
       m_map->setTransitionOptions(0, 0);
     }
-    if (change == QMapboxGL::MapChange::MapChangeDidFinishLoadingMap) {
+    if (change == QMapLibre::Map::MapChange::MapChangeDidFinishLoadingMap) {
       loaded_once = true;
     }
   });
@@ -381,10 +378,10 @@ void MapWindow::updateDestinationMarker() {
   auto nav_dest = coordinate_from_param("NavDestination");
   if (nav_dest.has_value()) {
     auto point = coordinate_to_collection(*nav_dest);
-    QMapbox::Feature feature(QMapbox::Feature::PointType, point, {}, {});
+    QMapLibre::Feature feature(QMapLibre::Feature::PointType, point, {}, {});
     QVariantMap pinSource;
     pinSource["type"] = "geojson";
-    pinSource["data"] = QVariant::fromValue<QMapbox::Feature>(feature);
+    pinSource["data"] = QVariant::fromValue<QMapLibre::Feature>(feature);
     m_map->updateSource("pinSource", pinSource);
     m_map->setPaintProperty("pinLayer", "visibility", "visible");
   } else {

selfdrive/ui/qt/maps/map.h

@@ -6,7 +6,8 @@
 #include <QGestureEvent>
 #include <QLabel>
 #include <QMap>
-#include <QMapboxGL>
+#include <QMapLibre/Map>
+#include <QMapLibre/Settings>
 #include <QMouseEvent>
 #include <QOpenGLWidget>
 #include <QPixmap>
@@ -27,16 +28,16 @@ class MapWindow : public QOpenGLWidget {
   Q_OBJECT
 
 public:
-  MapWindow(const QMapboxGLSettings &);
+  MapWindow(const QMapLibre::Settings &);
   ~MapWindow();
 
 private:
   void initializeGL() final;
   void paintGL() final;
   void resizeGL(int w, int h) override;
 
-  QMapboxGLSettings m_settings;
-  QScopedPointer<QMapboxGL> m_map;
+  QMapLibre::Settings m_settings;
+  QScopedPointer<QMapLibre::Map> m_map;
 
   void initLayers();
 
@@ -56,8 +57,8 @@ class MapWindow : public QOpenGLWidget {
   int interaction_counter = 0;
 
   // Position
-  std::optional<QMapbox::Coordinate> last_valid_nav_dest;
-  std::optional<QMapbox::Coordinate> last_position;
+  std::optional<QMapLibre::Coordinate> last_valid_nav_dest;
+  std::optional<QMapLibre::Coordinate> last_position;
   std::optional<float> last_bearing;
   FirstOrderFilter velocity_filter;
   bool locationd_valid = false;