refactor: use LaneKey instead of Lane references everywhere; get rid of Lane::key to align closer to OpenDrive data model

Author: pageldev

include/Lane.h

@@ -50,11 +50,10 @@ inline std::ostream& operator<<(std::ostream& os, const LaneKey& lk)
 
 struct Lane
 {
-    Lane(std::string road_id, double lanesection_s0, int id, bool level, std::string type);
+    Lane(int id, bool level, std::string type);
 
     std::vector<SingleRoadMark> get_roadmarks(const double s_start, const double s_end) const;
 
-    LaneKey     key;
     int         id;
     bool        level = false;
     std::string type = "";

include/Road.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "Geometries/CubicSpline.h"
+#include "Lane.h"
 #include "LaneSection.h"
 #include "Math.hpp"
 #include "Mesh.h"
@@ -97,20 +98,18 @@ class Road
     Vec3D get_xyz(const double s, const double t, const double h, Vec3D* e_s = nullptr, Vec3D* e_t = nullptr, Vec3D* e_h = nullptr) const;
     Vec3D get_surface_pt(double s, const double t, Vec3D* vn = nullptr) const;
 
-    Line3D get_lane_border_line(const Lane& lane, const double s_start, const double s_end, const double eps, const bool outer = true) const;
-    Line3D get_lane_border_line(const Lane& lane, const double eps, const bool outer = true) const;
+    Line3D get_lane_border_line(const LaneKey& lane_key, double s_start, double s_end, double eps, bool outer = true) const;
+    Line3D get_lane_border_line(const LaneKey& lane_key, double eps, bool outer = true) const;
 
-    Mesh3D get_lane_mesh(
-        const Lane& lane, const double s_start, const double s_end, const double eps, std::vector<uint32_t>* outline_indices = nullptr) const;
-    Mesh3D get_lane_mesh(const Lane& lane, const double eps, std::vector<uint32_t>* outline_indices = nullptr) const;
+    Mesh3D get_lane_mesh(const LaneKey& lane_key, double s_start, double s_end, double eps, std::vector<uint32_t>* outline_indices = nullptr) const;
+    Mesh3D get_lane_mesh(const LaneKey& lane_key, double eps, std::vector<uint32_t>* outline_indices = nullptr) const;
 
-    Mesh3D get_roadmark_mesh(const Lane& lane, const SingleRoadMark& roadmark, const double eps) const;
+    Mesh3D get_roadmark_mesh(const LaneKey& lane_key, const SingleRoadMark& roadmark, double eps) const;
     Mesh3D get_road_signal_mesh(const RoadSignal& road_signal) const;
-    Mesh3D get_road_object_mesh(const RoadObject& road_object, const double eps) const;
+    Mesh3D get_road_object_mesh(const RoadObject& road_object, double eps) const;
 
-    std::set<double>
-    approximate_lane_border_linear(const Lane& lane, const double s_start, const double s_end, const double eps, const bool outer = true) const;
-    std::set<double> approximate_lane_border_linear(const Lane& lane, const double eps, const bool outer = true) const;
+    std::set<double> approximate_lane_border_linear(const LaneKey& lane_key, double s_start, double s_end, double eps, bool outer = true) const;
+    std::set<double> approximate_lane_border_linear(const LaneKey& lane_key, double eps, bool outer = true) const;
 
     double      length = 0;
     std::string id = "";

src/Lane.cpp

@@ -19,10 +19,7 @@ std::string LaneKey::to_string() const
     return fmt::format("{}/{:.17g}/{}", this->road_id, this->lanesection_s0, this->lane_id);
 }
 
-Lane::Lane(std::string road_id, double lanesection_s0, int id, bool level, std::string type) :
-    key(road_id, lanesection_s0, id), id(id), level(level), type(type)
-{
-}
+Lane::Lane(int id, bool level, std::string type) : id(id), level(level), type(type) {}
 
 std::vector<SingleRoadMark> Lane::get_roadmarks(const double s_start, const double s_end) const
 {

src/OpenDriveMap.cpp

@@ -403,8 +403,7 @@ OpenDriveMap::OpenDriveMap(const std::string& xodr_file,
 
                 Lane& lane =
                     lanesection.id_to_lane
-                        .emplace(lane_id,
-                                 Lane(road_id, s0, lane_id, lane_node.attribute("level").as_bool(false), lane_node.attribute("type").as_string("")))
+                        .emplace(lane_id, Lane(lane_id, lane_node.attribute("level").as_bool(false), lane_node.attribute("type").as_string("")))
                         .first->second;
 
                 if (const pugi::xml_attribute id_attr = lane_node.child("link").child("predecessor").attribute("id"))
@@ -924,50 +923,46 @@ RoadNetworkMesh OpenDriveMap::get_road_network_mesh(const double eps) const
     RoadObjectsMesh& road_objects_mesh = out_mesh.road_objects_mesh;
     RoadSignalsMesh& road_signals_mesh = out_mesh.road_signals_mesh;
 
-    for (const auto& id_road : this->id_to_road)
+    for (const auto& [road_id, road] : this->id_to_road)
     {
-        const Road& road = id_road.second;
-        lanes_mesh.road_start_indices[lanes_mesh.vertices.size()] = road.id;
-        roadmarks_mesh.road_start_indices[roadmarks_mesh.vertices.size()] = road.id;
-        road_objects_mesh.road_start_indices[road_objects_mesh.vertices.size()] = road.id;
+        lanes_mesh.road_start_indices[lanes_mesh.vertices.size()] = road_id;
+        roadmarks_mesh.road_start_indices[roadmarks_mesh.vertices.size()] = road_id;
+        road_objects_mesh.road_start_indices[road_objects_mesh.vertices.size()] = road_id;
 
-        for (const auto& s_lanesec : road.s_to_lanesection)
+        for (const auto& [lanesec_s0, lanesec] : road.s_to_lanesection)
         {
-            const LaneSection& lanesec = s_lanesec.second;
-            lanes_mesh.lanesec_start_indices[lanes_mesh.vertices.size()] = lanesec.s0;
-            roadmarks_mesh.lanesec_start_indices[roadmarks_mesh.vertices.size()] = lanesec.s0;
-            for (const auto& id_lane : lanesec.id_to_lane)
+            lanes_mesh.lanesec_start_indices[lanes_mesh.vertices.size()] = lanesec_s0;
+            roadmarks_mesh.lanesec_start_indices[roadmarks_mesh.vertices.size()] = lanesec_s0;
+            for (const auto& [lane_id, lane] : lanesec.id_to_lane)
             {
-                const Lane&       lane = id_lane.second;
+                const LaneKey     lane_key(road_id, lanesec_s0, lane_id);
                 const std::size_t lanes_idx_offset = lanes_mesh.vertices.size();
-                lanes_mesh.lane_start_indices[lanes_idx_offset] = lane.id;
-                lanes_mesh.add_mesh(road.get_lane_mesh(lane, eps));
+                lanes_mesh.lane_start_indices[lanes_idx_offset] = lane_id;
+                lanes_mesh.add_mesh(road.get_lane_mesh(lane_key, eps));
 
                 std::size_t roadmarks_idx_offset = roadmarks_mesh.vertices.size();
-                roadmarks_mesh.lane_start_indices[roadmarks_idx_offset] = lane.id;
+                roadmarks_mesh.lane_start_indices[roadmarks_idx_offset] = lane_id;
                 const std::vector<SingleRoadMark> roadmarks = lane.get_roadmarks(lanesec.s0, road.get_lanesection_end(lanesec));
                 for (const SingleRoadMark& roadmark : roadmarks)
                 {
                     roadmarks_idx_offset = roadmarks_mesh.vertices.size();
                     roadmarks_mesh.roadmark_type_start_indices[roadmarks_idx_offset] = roadmark.type;
-                    roadmarks_mesh.add_mesh(road.get_roadmark_mesh(lane, roadmark, eps));
+                    roadmarks_mesh.add_mesh(road.get_roadmark_mesh(lane_key, roadmark, eps));
                 }
             }
         }
 
-        for (const auto& id_road_object : road.id_to_object)
+        for (const auto& [road_object_id, road_object] : road.id_to_object)
         {
-            const RoadObject& road_object = id_road_object.second;
             const std::size_t road_objs_idx_offset = road_objects_mesh.vertices.size();
-            road_objects_mesh.road_object_start_indices[road_objs_idx_offset] = road_object.id;
+            road_objects_mesh.road_object_start_indices[road_objs_idx_offset] = road_object_id;
             road_objects_mesh.add_mesh(road.get_road_object_mesh(road_object, eps));
         }
 
-        for (const auto& id_signal : road.id_to_signal)
+        for (const auto& [road_signal_id, road_signal] : road.id_to_signal)
         {
-            const RoadSignal& road_signal = id_signal.second;
             const std::size_t signals_idx_offset = road_signals_mesh.vertices.size();
-            road_signals_mesh.road_signal_start_indices[signals_idx_offset] = road_signal.id;
+            road_signals_mesh.road_signal_start_indices[signals_idx_offset] = road_signal_id;
             road_signals_mesh.add_mesh(road.get_road_signal_mesh(road_signal));
         }
     }

src/Road.cpp

@@ -212,18 +212,14 @@ Vec3D Road::get_surface_pt(double s, const double t, Vec3D* vn) const
     return this->get_xyz(s, t, h, nullptr, nullptr, vn);
 }
 
-std::set<double>
-Road::approximate_lane_border_linear(const Lane& lane, const double s_start, const double s_end, const double eps, const bool outer) const
+std::set<double> Road::approximate_lane_border_linear(const LaneKey& lane_key, double s_start, double s_end, double eps, bool outer) const
 {
+    const LaneSection& lanesection = this->s_to_lanesection.at(lane_key.lanesection_s0);
+    const Lane&        lane = lanesection.id_to_lane.at(lane_key.lane_id);
+
     std::set<double> s_vals = this->ref_line.approximate_linear(eps, s_start, s_end);
 
-    CubicProfile border = lane.outer_border;
-    if (!outer)
-    {
-        const LaneSection& lanesection = this->s_to_lanesection.at(lane.key.lanesection_s0);
-        const Lane&        inner_neighbor_lane = lanesection.get_lane(next_towards_zero(lane.id));
-        border = inner_neighbor_lane.outer_border;
-    }
+    const CubicProfile border = outer ? lane.outer_border : lanesection.id_to_lane.at(next_towards_zero(lane.id)).outer_border;
 
     std::set<double> s_vals_brdr = border.approximate_linear(eps, s_start, s_end);
     s_vals.insert(s_vals_brdr.begin(), s_vals_brdr.end());
@@ -238,23 +234,20 @@ Road::approximate_lane_border_linear(const Lane& lane, const double s_start, con
     return s_vals;
 }
 
-std::set<double> Road::approximate_lane_border_linear(const Lane& lane, const double eps, const bool outer) const
+std::set<double> Road::approximate_lane_border_linear(const LaneKey& lane_key, double eps, bool outer) const
 {
-    const double s_end = this->get_lanesection_end(lane.key.lanesection_s0);
-    return this->approximate_lane_border_linear(lane, lane.key.lanesection_s0, s_end, eps, outer);
+    const double lanesec_s_end = this->get_lanesection_end(lane_key.lanesection_s0);
+    return this->approximate_lane_border_linear(lane_key, lane_key.lanesection_s0, lanesec_s_end, eps, outer);
 }
 
-Line3D Road::get_lane_border_line(const Lane& lane, const double s_start, const double s_end, const double eps, const bool outer) const
+Line3D Road::get_lane_border_line(const LaneKey& lane_key, double s_start, double s_end, double eps, bool outer) const
 {
-    std::set<double> s_vals = this->approximate_lane_border_linear(lane, s_start, s_end, eps, outer);
+    const LaneSection& lanesection = this->s_to_lanesection.at(lane_key.lanesection_s0);
+    const Lane&        lane = lanesection.id_to_lane.at(lane_key.lane_id);
 
-    CubicProfile border = lane.outer_border;
-    if (!outer)
-    {
-        const LaneSection& lanesection = this->s_to_lanesection.at(lane.key.lanesection_s0);
-        const Lane&        inner_neighbor_lane = lanesection.get_lane(next_towards_zero(lane.id));
-        border = inner_neighbor_lane.outer_border;
-    }
+    std::set<double> s_vals = this->approximate_lane_border_linear(lane_key, s_start, s_end, eps, outer);
+
+    const CubicProfile border = outer ? lane.outer_border : lanesection.id_to_lane.at(next_towards_zero(lane.id)).outer_border;
 
     Line3D border_line;
     for (const double& s : s_vals)
@@ -268,21 +261,23 @@ Line3D Road::get_lane_border_line(const Lane& lane, const double s_start, const
     return border_line;
 }
 
-Line3D Road::get_lane_border_line(const Lane& lane, const double eps, const bool outer) const
+Line3D Road::get_lane_border_line(const LaneKey& lane_key, double eps, bool outer) const
 {
-    const double s_end = this->get_lanesection_end(lane.key.lanesection_s0);
-    return this->get_lane_border_line(lane, lane.key.lanesection_s0, s_end, eps, outer);
+    const double lanesec_s_end = this->get_lanesection_end(lane_key.lanesection_s0);
+    return this->get_lane_border_line(lane_key, lane_key.lanesection_s0, lanesec_s_end, eps, outer);
 }
 
-Mesh3D Road::get_lane_mesh(const Lane& lane, const double s_start, const double s_end, const double eps, std::vector<uint32_t>* outline_indices) const
+Mesh3D Road::get_lane_mesh(const LaneKey& lane_key, double s_start, double s_end, double eps, std::vector<uint32_t>* outline_indices) const
 {
+    const LaneSection& lanesection = this->s_to_lanesection.at(lane_key.lanesection_s0);
+    const Lane&        lane = lanesection.id_to_lane.at(lane_key.lane_id);
+
     std::set<double> s_vals = this->ref_line.approximate_linear(eps, s_start, s_end);
     std::set<double> s_vals_outer_brdr = lane.outer_border.approximate_linear(eps, s_start, s_end);
     s_vals.insert(s_vals_outer_brdr.begin(), s_vals_outer_brdr.end());
 
-    const LaneSection& lanesection = this->s_to_lanesection.at(lane.key.lanesection_s0);
-    const Lane&        inner_neighbor_lane = lanesection.get_lane(next_towards_zero(lane.id));
-    std::set<double>   s_vals_inner_brdr = inner_neighbor_lane.outer_border.approximate_linear(eps, s_start, s_end);
+    const Lane&      inner_neighbor_lane = lanesection.get_lane(next_towards_zero(lane.id));
+    std::set<double> s_vals_inner_brdr = inner_neighbor_lane.outer_border.approximate_linear(eps, s_start, s_end);
     s_vals.insert(s_vals_inner_brdr.begin(), s_vals_inner_brdr.end());
     std::set<double> s_vals_lane_offset = this->lane_offset.approximate_linear(eps, s_start, s_end);
     s_vals.insert(s_vals_lane_offset.begin(), s_vals_lane_offset.end());
@@ -333,25 +328,26 @@ Mesh3D Road::get_lane_mesh(const Lane& lane, const double s_start, const double
     }
 
     if (outline_indices)
-    {
         *outline_indices = get_triangle_strip_outline_indices<uint32_t>(out_mesh.vertices.size());
-    }
 
     return out_mesh;
 }
 
-Mesh3D Road::get_lane_mesh(const Lane& lane, const double eps, std::vector<uint32_t>* outline_indices) const
+Mesh3D Road::get_lane_mesh(const LaneKey& lane_key, double eps, std::vector<uint32_t>* outline_indices) const
 {
-    const double s_end = this->get_lanesection_end(lane.key.lanesection_s0);
-    return this->get_lane_mesh(lane, lane.key.lanesection_s0, s_end, eps, outline_indices);
+    const double lanesec_s_end = this->get_lanesection_end(lane_key.lanesection_s0);
+    return this->get_lane_mesh(lane_key, lane_key.lanesection_s0, lanesec_s_end, eps, outline_indices);
 }
 
-Mesh3D Road::get_roadmark_mesh(const Lane& lane, const SingleRoadMark& roadmark, const double eps) const
+Mesh3D Road::get_roadmark_mesh(const LaneKey& lane_key, const SingleRoadMark& roadmark, double eps) const
 {
     if (is_zero(roadmark.width))
         return Mesh3D{};
 
-    const std::set<double> s_vals = this->approximate_lane_border_linear(lane, roadmark.s0, roadmark.s1, eps, true);
+    const LaneSection& lanesection = this->s_to_lanesection.at(lane_key.lanesection_s0);
+    const Lane&        lane = lanesection.id_to_lane.at(lane_key.lane_id);
+
+    const std::set<double> s_vals = this->approximate_lane_border_linear(lane_key, roadmark.s0, roadmark.s1, eps, true);
 
     Mesh3D out_mesh;
     for (const double& s : s_vals)
@@ -402,7 +398,7 @@ Mesh3D Road::get_road_signal_mesh(const RoadSignal& road_signal) const
     return road_signal_mesh;
 }
 
-Mesh3D Road::get_road_object_mesh(const RoadObject& road_obj, const double eps) const
+Mesh3D Road::get_road_object_mesh(const RoadObject& road_obj, double eps) const
 {
     std::vector<RoadObjectRepeat> repeats_copy = road_obj.repeats; // make copy to keep method const
     if (repeats_copy.empty() && road_obj.outlines.empty())         // handle single road object as one object repeat