Merge branch 'main' into webapp

Author: Grufoony

src/dsm/dsm.hpp

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

src/dsm/headers/AdjacencyMatrix.hpp

@@ -74,6 +74,9 @@ namespace dsm {
     /// @brief Get the number of links in the adjacency matrix
     /// @return The number of links in the adjacency matrix
     size_t size() const;
+    /// @brief Check if the adjacency matrix is empty
+    /// @return True if the adjacency matrix is empty, false otherwise
+    bool empty() const;
     /// @brief Get the number of nodes in the adjacency matrix
     /// @return The number of nodes in the adjacency matrix
     size_t n() const;

src/dsm/headers/DijkstraWeights.hpp

@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include "../utility/Typedef.hpp"
@@ -7,7 +6,20 @@ namespace dsm {
 
   class Graph;
 
-  double streetLength(const Graph* graph, Id node1, Id node2);
-  double streetTime(const Graph* graph, Id node1, Id node2);
+  namespace weight_functions {
+    /// @brief Returns the length of a street given its source and destination nodes
+    /// @param graph A pointer to the graph
+    /// @param node1 The source node id
+    /// @param node2 The destination node id
+    /// @return The length of the street
+    double streetLength(const Graph* graph, Id node1, Id node2);
+    /// @brief Returns the time to cross a street given its source and destination nodes
+    /// @param graph A pointer to the graph
+    /// @param node1 The source node id
+    /// @param node2 The destination node id
+    /// @return The time to cross the street
+    /// @details This time also takes into account the number of agents on the street
+    double streetTime(const Graph* graph, Id node1, Id node2);
+  }  // namespace weight_functions
 
 };  // namespace dsm

src/dsm/headers/Dynamics.hpp

@@ -23,6 +23,7 @@
 #include <exception>
 #include <fstream>
 #include <filesystem>
+#include <functional>
 #include <tbb/parallel_for_each.h>
 
 #include "DijkstraWeights.hpp"
@@ -72,6 +73,8 @@ namespace dsm {
   private:
     std::map<Id, std::unique_ptr<agent_t>> m_agents;
     std::unordered_map<Id, std::unique_ptr<Itinerary>> m_itineraries;
+    std::function<double(const Graph*, Id, Id)> m_weightFunction;
+    double m_weightTreshold;
     bool m_bCacheEnabled;
 
   protected:
@@ -97,7 +100,6 @@ namespace dsm {
         }
       }
 
-      auto const dimension = static_cast<Size>(m_graph.nNodes());
       auto const destinationID = pItinerary->destination();
       std::vector<double> shortestDistances(m_graph.nNodes());
       tbb::parallel_for_each(
@@ -108,7 +110,7 @@ namespace dsm {
             if (nodeId == destinationID) {
               shortestDistances[nodeId] = -1.;
             } else {
-              auto result = m_graph.shortestPath(nodeId, destinationID);
+              auto result = m_graph.shortestPath(nodeId, destinationID, m_weightFunction);
               if (result.has_value()) {
                 shortestDistances[nodeId] = result.value().distance();
               } else {
@@ -132,17 +134,17 @@ namespace dsm {
         auto const& row{m_graph.adjMatrix().getRow(nodeId)};
         for (const auto nextNodeId : row) {
           if (nextNodeId == destinationID) {
-            if (std::abs(m_graph.street(nodeId * dimension + nextNodeId)->length() -
-                         minDistance) < 1.)  // 1 meter tolerance between shortest paths
+            if (std::abs(m_weightFunction(&m_graph, nodeId, nextNodeId) - minDistance) <
+                m_weightTreshold)  // 1 meter tolerance between shortest paths
             {
               path.insert(nodeId, nextNodeId);
             } else {
               Logger::debug(
                   std::format("Found a path from {} to {} which differs for more than {} "
-                              "meter(s) from the shortest one.",
+                              "unit(s) from the shortest one.",
                               nodeId,
                               destinationID,
-                              1.));
+                              m_weightTreshold));
             }
             continue;
           }
@@ -151,23 +153,23 @@ namespace dsm {
             continue;
           }
           bool const bIsMinDistance{
-              std::abs(m_graph.street(nodeId * dimension + nextNodeId)->length() +
-                       distance - minDistance) <
-              1.};  // 1 meter tolerance between shortest paths
+              std::abs(m_weightFunction(&m_graph, nodeId, nextNodeId) + distance -
+                       minDistance) <
+              m_weightTreshold};  // 1 meter tolerance between shortest paths
           if (bIsMinDistance) {
             path.insert(nodeId, nextNodeId);
           } else {
             Logger::debug(
                 std::format("Found a path from {} to {} which differs for more than {} "
-                            "meter(s) from the shortest one.",
+                            "unit(s) from the shortest one.",
                             nodeId,
                             destinationID,
-                            1.));
+                            m_weightTreshold));
           }
         }
       }
 
-      if (path.size() == 0) {
+      if (path.empty()) {
         Logger::error(
             std::format("Path with id {} and destination {} is empty. Please check the "
                         "adjacency matrix.",
@@ -199,6 +201,19 @@ namespace dsm {
     /// @brief Update the paths of the itineraries based on the actual travel times
     virtual void updatePaths();
 
+    /// @brief Set the weight function for the Dijkstra's algorithm
+    /// @param weightFunction A std::function returning a double value and taking as arguments a
+    /// pointer to the graph, an id of a source node and an id of a target node (for the edge)
+    /// @details The weight function must return the weight of the edge between the source and the
+    /// target node. One can use the predefined weight functions in the DijkstraWeights.hpp file,
+    /// like weight_functions::streetLength or weight_functions::streetTime.
+    void setWeightFunction(std::function<double(const Graph*, Id, Id)> weightFunction);
+    /// @brief Set the weight treshold for updating the paths
+    /// @param weightTreshold The weight treshold
+    /// @details If two paths differs only for a weight smaller than the treshold, the two paths are
+    /// considered equivalent.
+    void setWeightTreshold(double weightTreshold) { m_weightTreshold = weightTreshold; }
+
     /// @brief Set the destination nodes
     /// @param destinationNodes The destination nodes (as an initializer list)
     /// @param updatePaths If true, the paths are updated
@@ -343,7 +358,9 @@ namespace dsm {
   Dynamics<agent_t>::Dynamics(Graph& graph,
                               bool useCache,
                               std::optional<unsigned int> seed)
-      : m_bCacheEnabled{useCache},
+      : m_weightFunction{weight_functions::streetLength},
+        m_weightTreshold{1.},
+        m_bCacheEnabled{useCache},
         m_graph{std::move(graph)},
         m_time{0},
         m_previousSpireTime{0},
@@ -371,6 +388,12 @@ namespace dsm {
         });
   }
 
+  template <typename agent_t>
+  void Dynamics<agent_t>::setWeightFunction(
+      std::function<double(const Graph*, Id, Id)> weightFunction) {
+    m_weightFunction = weightFunction;
+  }
+
   template <typename agent_t>
   void Dynamics<agent_t>::setDestinationNodes(std::initializer_list<Id> destinationNodes,
                                               bool updatePaths) {
@@ -546,7 +569,7 @@ namespace dsm {
 
   template <typename agent_t>
   Measurement<double> Dynamics<agent_t>::streetMeanDensity(bool normalized) const {
-    if (m_graph.streetSet().size() == 0) {
+    if (m_graph.streetSet().empty()) {
       return Measurement(0., 0.);
     }
     std::vector<double> densities;

src/dsm/headers/Edge.hpp

@@ -1,17 +1,22 @@
 #pragma once
 
 #include <utility>
+#include <vector>
 #include "../utility/Typedef.hpp"
 
 namespace dsm {
   class Edge {
   protected:
+    std::vector<std::pair<double, double>> m_geometry;
     Id m_id;
     std::pair<Id, Id> m_nodePair;
     int m_capacity;
     int m_transportCapacity;
     double m_angle;
 
+    void m_setAngle(std::pair<double, double> srcNodeCoordinates,
+                    std::pair<double, double> dstNodeCoordinates);
+
   public:
     /// @brief Construct a new Edge object
     /// @param id The edge's id
@@ -25,12 +30,11 @@ namespace dsm {
          std::pair<Id, Id> nodePair,
          int capacity = 1,
          int transportCapacity = 1,
-         double angle = 0.0);
+         std::vector<std::pair<double, double>> geometry = {});
 
     void setCapacity(int capacity);
     void setTransportCapacity(int capacity);
-    void setAngle(std::pair<double, double> srcNodeCoordinates,
-                  std::pair<double, double> dstNodeCoordinates);
+    void setGeometry(std::vector<std::pair<double, double>> geometry);
 
     /// @brief Get the edge's id
     /// @return Id The edge's id
@@ -45,6 +49,8 @@ namespace dsm {
     /// @return std::pair<Id, Id> The edge's node pair, where the first element is the source node id and the second
     /// element is the target node id. The pair is (u, v) with the edge u -> v.
     std::pair<Id, Id> const& nodePair() const;
+
+    std::vector<std::pair<double, double>> const& geometry() const;
     /// @brief Get the edge's capacity, in number of agents
     /// @return int The edge's capacity, in number of agents
     int capacity() const;

src/dsm/headers/Graph.hpp

@@ -49,8 +49,8 @@ namespace dsm {
   private:
     std::unordered_map<Id, std::unique_ptr<Node>> m_nodes;
     std::unordered_map<Id, std::unique_ptr<Street>> m_streets;
-    std::unordered_map<std::string, Id> m_nodeMapping;
     AdjacencyMatrix m_adjacencyMatrix;
+    std::unordered_map<std::string, Id> m_nodeMapping;
     std::vector<Id> m_inputNodes;
     std::vector<Id> m_outputNodes;
     unsigned long long m_maxAgentCapacity;
@@ -110,9 +110,8 @@ namespace dsm {
     /// @brief Build the graph's adjacency matrix and computes max capacity
     /// @details The adjacency matrix is built using the graph's streets and nodes. N.B.: The street ids
     /// are reassigned using the max node id, i.e. newStreetId = srcId * n + dstId, where n is the max node id.
+    /// Moreover, street angles and geometries are set using the nodes' coordinates.
     void buildAdj();
-    /// @brief Build the graph's street angles using the node's coordinates
-    void buildStreetAngles();
     /// @brief Adjust the nodes' transport capacity
     /// @details The nodes' capacity is adjusted using the graph's streets transport capacity, which may vary basing on the number of lanes. The node capacity will be set to the sum of the incoming streets' transport capacity.
     void adjustNodeCapacities();
@@ -144,14 +143,19 @@ namespace dsm {
     /// @throws std::invalid_argument if the file is not found, invalid or the format is not supported
     void importOSMEdges(const std::string& fileName);
 
+    /// @brief Export the graph's nodes to a csv-like file separated with ';'
+    /// @param path The path to the file to export the nodes to
+    /// @details The file format is csv-like, with the first line being the column names: id;lon;lat
+    void exportNodes(const std::string& fileName);
+    /// @brief Export the graph's edges to a csv-like file separated with ';'
+    /// @param path The path to the file to export the edges to
+    /// @details The file format is csv-like, with the first line being the column names: id;source_id;target_id;name;geometry
+    void exportEdges(const std::string& fileName);
     /// @brief Export the graph's adjacency matrix to a file
     /// @param path The path to the file to export the adjacency matrix to (default: ./matrix.dsm)
     /// @param isAdj A boolean value indicating if the file contains the adjacency matrix or the distance matrix.
     /// @throws std::invalid_argument if the file is not found or invalid
     void exportMatrix(std::string path = "./matrix.dsm", bool isAdj = true);
-    /// @brief Export the nodes' coordinates to a file
-    /// @param path The path to the file to export the nodes' coordinates to (default: ./nodes.dsm)
-    void exportCoordinates(std::string const& path = "./coordinates.csv");
 
     /// @brief Add a node to the graph
     /// @param node A std::unique_ptr to the node to add
@@ -276,19 +280,19 @@ namespace dsm {
     /// @return A DijkstraResult object containing the path and the distance
     template <typename Func = std::function<double(const Graph*, Id, Id)>>
       requires(std::is_same_v<std::invoke_result_t<Func, const Graph*, Id, Id>, double>)
-    std::optional<DijkstraResult> shortestPath(const Node& source,
-                                               const Node& destination,
-                                               Func f = streetLength) const;
+    std::optional<DijkstraResult> shortestPath(
+        const Node& source,
+        const Node& destination,
+        Func f = weight_functions::streetLength) const;
 
     /// @brief Get the shortest path between two nodes using dijkstra algorithm
     /// @param source The source node id
     /// @param destination The destination node id
     /// @return A DijkstraResult object containing the path and the distance
     template <typename Func = std::function<double(const Graph*, Id, Id)>>
       requires(std::is_same_v<std::invoke_result_t<Func, const Graph*, Id, Id>, double>)
-    std::optional<DijkstraResult> shortestPath(Id source,
-                                               Id destination,
-                                               Func f = streetLength) const;
+    std::optional<DijkstraResult> shortestPath(
+        Id source, Id destination, Func f = weight_functions::streetLength) const;
   };
 
   template <typename node_t, typename... TArgs>

src/dsm/headers/Road.hpp

@@ -36,6 +36,7 @@ namespace dsm {
          double maxSpeed = 13.8888888889,
          int nLanes = 1,
          std::string name = std::string(),
+         std::vector<std::pair<double, double>> geometry = {},
          std::optional<int> capacity = std::nullopt,
          int transportCapacity = 1);
     /// @brief Set the mean vehicle length, in meters (default is 5)