Add autoMapStreetLanes function to RoadNetwork class

src/dsm/dsm.hpp

@@ -6,7 +6,7 @@
 
 static constexpr uint8_t DSM_VERSION_MAJOR = 2;
 static constexpr uint8_t DSM_VERSION_MINOR = 6;
-static constexpr uint8_t DSM_VERSION_PATCH = 2;
+static constexpr uint8_t DSM_VERSION_PATCH = 3;
 
 static auto const DSM_VERSION =
     std::format("{}.{}.{}", DSM_VERSION_MAJOR, DSM_VERSION_MINOR, DSM_VERSION_PATCH);

src/dsm/headers/RoadDynamics.hpp

@@ -1556,7 +1556,7 @@ namespace dsm {
           continue;
         }
         auto& spire = dynamic_cast<SpireStreet&>(*pStreet);
-        file << separator << spire.code();
+        file << separator << streetId;
       }
       file << std::endl;
     }

src/dsm/headers/RoadNetwork.hpp

@@ -85,6 +85,9 @@ namespace dsm {
     /// Street priorities are assigned considering the number of lanes and the speed limit.
     /// Traffic Lights with an input degree lower than 3 are converted to standard intersections.
     void initTrafficLights();
+    /// @brief Automatically re-maps street lanes basing on network's topology
+    /// @details For example, if one street has the right turn forbidden, then the right lane becomes a straight one
+    void autoMapStreetLanes();
 
     /// @brief Import the graph's adjacency matrix from a file.
     /// If the file is not of a supported format, it will read the file as a matrix with the first two elements being

src/dsm/sources/RoadNetwork.cpp

@@ -151,7 +151,7 @@
           }
         }
         // continue;
       }
       // Set first two elements of capacities to street priorities
       // auto it{capacities.begin()};
       // tl.addStreetPriority(it->first);
@@ -239,6 +239,77 @@
       });
     }
   }
+  void RoadNetwork::autoMapStreetLanes() {
+    std::for_each(m_nodes.cbegin(), m_nodes.cend(), [this](auto const& pair) {
+      auto const& inNeighbours{m_adjacencyMatrix.getCol(pair.first)};
+      auto const& outNeighbours{m_adjacencyMatrix.getRow(pair.first)};
+      std::for_each(
+          inNeighbours.cbegin(),
+          inNeighbours.cend(),
+          [this, &pair, &outNeighbours](auto const& inNodeId) {
+            auto const& pInStreet{m_edges.at(inNodeId * m_nodes.size() + pair.first)};
+            auto const& laneMapping{pInStreet->laneMapping()};
+            auto const angle{pInStreet->angle()};
+            std::set<Direction> allowedTurns;
+            std::for_each(outNeighbours.cbegin(),
+                          outNeighbours.cend(),
+                          [this, &pair, &angle, &allowedTurns](auto const& outNodeId) {
+                            auto const& pOutStreet{
+                                m_edges.at(pair.first * m_nodes.size() + outNodeId)};
+                            auto const deltaAngle{pOutStreet->deltaAngle(angle)};
+                            // Logger::debug(std::format("Angle in {} - angle out {}", angle, pOutStreet->angle()));
+                            if (std::abs(deltaAngle) < 5 * std::numbers::pi / 6) {
+                              // Logger::debug(std::format("Delta: {}", deltaAngle));
+                              if (deltaAngle < -std::numbers::pi / 6.) {
+                                allowedTurns.emplace(Direction::RIGHT);
+                              } else if (deltaAngle > std::numbers::pi / 6.) {
+                                allowedTurns.emplace(Direction::LEFT);
+                              }
+                            }
+                          });
+            auto const nLanes{pInStreet->nLanes()};
+            std::vector<Direction> newMapping(nLanes, Direction::STRAIGHT);
+            switch (nLanes) {
+              case 1:
+                // if (!allowedTurns.contains(Direction::RIGHT) &&
+                //     !allowedTurns.contains(Direction::LEFT)) {
+                //   pInStreet->setLaneMapping(std::vector<Direction>{Direction::STRAIGHT});
+                // } else if (!allowedTurns.contains(Direction::RIGHT)) {
+                //   pInStreet->setLaneMapping(
+                //       std::vector<Direction>{Direction::LEFTANDSTRAIGHT});
+                // } else if (!allowedTurns.contains(Direction::LEFT)) {
+                //   pInStreet->setLaneMapping(
+                //       std::vector<Direction>{Direction::RIGHTANDSTRAIGHT});
+                // }
+                break;
+              case 2:
+                if (!allowedTurns.contains(Direction::RIGHT) &&
+                    !allowedTurns.contains(Direction::LEFT)) {
+                  pInStreet->setLaneMapping(newMapping);
+                } else if (!allowedTurns.contains(Direction::RIGHT)) {
+                  newMapping[0] = Direction::STRAIGHT;
+                  pInStreet->setLaneMapping(newMapping);
+                } else if (!allowedTurns.contains(Direction::LEFT)) {
+                  newMapping = {Direction::RIGHT, Direction::STRAIGHT};
+                  pInStreet->setLaneMapping(newMapping);
+                }
+                break;
+              default:
+                if (!allowedTurns.contains(Direction::RIGHT) &&
+                    !allowedTurns.contains(Direction::LEFT)) {
+                  pInStreet->setLaneMapping(newMapping);
+                } else if (!allowedTurns.contains(Direction::RIGHT)) {
+                  newMapping[0] = Direction::STRAIGHT;
+                  pInStreet->setLaneMapping(newMapping);
+                } else if (!allowedTurns.contains(Direction::LEFT)) {
+                  newMapping[0] = Direction::RIGHT;
+                  newMapping[nLanes - 1] = Direction::STRAIGHT;
+                  pInStreet->setLaneMapping(newMapping);
+                }
+            }
+          });
+    });
+  }
 
   void RoadNetwork::buildAdj() {
     // find max values in streets node pairs

src/dsm/sources/Street.cpp

@@ -53,6 +53,13 @@
   void Street::setLaneMapping(std::vector<Direction> const& laneMapping) {
     assert(laneMapping.size() == static_cast<size_t>(m_nLanes));
     m_laneMapping = laneMapping;
+    std::string strLaneMapping;
+    std::for_each(
+        laneMapping.cbegin(), laneMapping.cend(), [&strLaneMapping](auto const item) {
+          strLaneMapping += std::format("{} - ", static_cast<int>(item));
+        });
+    Logger::debug(
+        std::format("New lane mapping for street {} is: {}", m_id, strLaneMapping));
   }
   void Street::setQueue(dsm::queue<std::unique_ptr<Agent>> queue, size_t index) {
     assert(index < m_exitQueues.size());