Change input/output notation to origin/destination (#309)

* Change input/output notation to origin/destination

* Removing unused functions

* Update version and docs

Author: Grufoony

src/dsf/dsf.hpp

@@ -5,8 +5,8 @@
 #include <format>
 
 static constexpr uint8_t DSF_VERSION_MAJOR = 3;
-static constexpr uint8_t DSF_VERSION_MINOR = 1;
-static constexpr uint8_t DSF_VERSION_PATCH = 1;
+static constexpr uint8_t DSF_VERSION_MINOR = 2;
+static constexpr uint8_t DSF_VERSION_PATCH = 0;
 
 static auto const DSF_VERSION =
     std::format("{}.{}.{}", DSF_VERSION_MAJOR, DSF_VERSION_MINOR, DSF_VERSION_PATCH);

src/dsf/headers/RoadDynamics.hpp

@@ -392,7 +392,7 @@ namespace dsf {
       }
       Logger::info(std::format("Cache enabled (default folder is {})", g_cacheFolder));
     }
-    for (const auto& nodeId : this->graph().outputNodes()) {
+    for (const auto& nodeId : this->graph().destinationNodes()) {
       this->addItinerary(nodeId, nodeId);
     }
     // updatePaths();
@@ -1361,10 +1361,10 @@ namespace dsf {
   void RoadDynamics<delay_t>::addAgentsRandomly(
       Size nAgents, const std::variant<std::monostate, size_t, double> minNodeDistance) {
     std::unordered_map<Id, double> src_weights, dst_weights;
-    for (auto const& id : this->graph().inputNodes()) {
+    for (auto const& id : this->graph().originNodes()) {
       src_weights[id] = 1.;
     }
-    for (auto const& id : this->graph().outputNodes()) {
+    for (auto const& id : this->graph().destinationNodes()) {
       dst_weights[id] = 1.;
     }
     addAgentsRandomly(nAgents, src_weights, dst_weights, minNodeDistance);

src/dsf/headers/RoadNetwork.hpp

@@ -49,8 +49,8 @@ namespace dsf {
   class RoadNetwork : public Network<RoadJunction, Street> {
   private:
     std::unordered_map<std::string, Id> m_nodeMapping;
-    std::vector<Id> m_inputNodes;
-    std::vector<Id> m_outputNodes;
+    std::vector<Id> m_originNodes;
+    std::vector<Id> m_destinationNodes;
     unsigned long long m_maxAgentCapacity;
 
     /// @brief Reassign the street ids using the max node id
@@ -111,6 +111,15 @@ namespace dsf {
     /// @brief Import the graph's nodes from a file
     /// @param fileName The name of the file to import the nodes from.
     /// @throws std::invalid_argument if the file is not found, invalid or the format is not supported
+    /// @details The file format is csv-like with the ';' separator. Supported columns (in order):
+    /// - id: The id of the node
+    /// - lon: The x coordinate of the node
+    /// - lat: The y coordinate of the node
+    /// - type: The type of the node
+    /// The node type can be one of the following:
+    /// - traffic_signals: intersection + traffic light
+    /// - roundabout
+    /// - origin/destination: intesection counted as origin, destination or both. To have both, the string must contain both the strings "origin" and "destination".
     void importOSMNodes(const std::string& fileName);
     /// @brief Import the graph's streets from a file
     /// @param fileName The name of the file to import the streets from.
@@ -226,18 +235,20 @@ namespace dsf {
       return m_nodeMapping;
     }
 
-    /// @brief Get the input nodes of the graph
-    /// @return std::vector<Id> const& The input nodes of the graph
-    inline std::vector<Id> const& inputNodes() const noexcept { return m_inputNodes; }
-    /// @brief Get the input nodes of the graph
-    /// @return std::vector<Id>& The input nodes of the graph
-    inline std::vector<Id>& inputNodes() noexcept { return m_inputNodes; }
-    /// @brief Get the output nodes of the graph
-    /// @return std::vector<Id> const& The output nodes of the graph
-    inline std::vector<Id> const& outputNodes() const noexcept { return m_outputNodes; }
-    /// @brief Get the output nodes of the graph
-    /// @return std::vector<Id>& The output nodes of the graph
-    inline std::vector<Id>& outputNodes() noexcept { return m_outputNodes; }
+    /// @brief Get the origin nodes of the graph
+    /// @return std::vector<Id> const& The origin nodes of the graph
+    inline std::vector<Id> const& originNodes() const noexcept { return m_originNodes; }
+    /// @brief Get the origin nodes of the graph
+    /// @return std::vector<Id>& The origin nodes of the graph
+    inline std::vector<Id>& originNodes() noexcept { return m_originNodes; }
+    /// @brief Get the destination nodes of the graph
+    /// @return std::vector<Id> const& The destination nodes of the graph
+    inline std::vector<Id> const& destinationNodes() const noexcept {
+      return m_destinationNodes;
+    }
+    /// @brief Get the destination nodes of the graph
+    /// @return std::vector<Id>& The destination nodes of the graph
+    inline std::vector<Id>& destinationNodes() noexcept { return m_destinationNodes; }
 
     /// @brief Get the shortest path between two nodes using dijkstra algorithm
     /// @param source The source node

src/dsf/headers/TrafficLight.hpp

@@ -78,25 +78,9 @@ namespace dsf {
     ~TrafficLight() = default;
 
     TrafficLight& operator++();
-    /// @brief Get the maximum green time over every cycle
-    /// @param priorityStreets bool, if true, only the priority streets are considered;
-    ///        if false, only the non-priority streets are considered
-    /// @return Delay The maximum green time
-    /// @details The maximum green time is the maximum green time of all the cycles for
-    ///          the priority streets if priorityStreets is true, or for the non-priority
-    ///          streets if priorityStreets is false.
 
     static void setAllowFreeTurns(bool allow);
 
-    Delay maxGreenTime(bool priorityStreets) const;
-    /// @brief Get the minimum green time over every cycle
-    /// @param priorityStreets bool, if true, only the priority streets are considered;
-    ///        if false, only the non-priority streets are considered
-    /// @return Delay The minimum green time
-    /// @details The minimum green time is the minimum green time of all the cycles for
-    ///          the priority streets if priorityStreets is true, or for the non-priority
-    ///          streets if priorityStreets is false.
-    Delay minGreenTime(bool priorityStreets) const;
     /// @brief Get the mean green time over every cycle
     /// @param priorityStreets bool, if true, only the priority streets are considered;
     ///        if false, only the non-priority streets are considered
@@ -132,12 +116,6 @@ namespace dsf {
     /// @param oldStreetId Id, the old street id
     /// @param newStreetId Id, the new street id
     void moveCycle(Id const oldStreetId, Id const newStreetId);
-    /// @brief Increase the green times of the traffic light for priority streets and decrease the green times for non-priority streets
-    /// @param delta Delay, the time to increase or decrease the green times
-    void increaseGreenTimes(Delay const delta);
-    /// @brief Decrease the green times of the traffic light for priority streets and increase the green times for non-priority streets
-    /// @param delta Delay, the time to increase or decrease the green times
-    void decreaseGreenTimes(Delay const delta);
     /// @brief Increase the phase times of the traffic light cycles
     /// @param phase Delay, the amount of time to increase the phase for each cycle
     void increasePhases(Delay const phase);
@@ -155,10 +133,6 @@ namespace dsf {
     /// @param direction Direction, the direction
     /// @return true if the traffic light is green for the street and direction
     bool isGreen(Id const streetId, Direction direction) const;
-    /// @brief Returns true if the traffic light has green increased for all the cycles with priority
-    /// @param priority bool, if true, only the priority streets are considered; else, only the non-priority streets are considered
-    /// @return true if the traffic light has green increased for all the cycles with priority
-    bool isFavouringDirection(bool const priority) const;
     /// @brief Resets all traffic light cycles
     /// @details For more info, see @ref TrafficLightCycle::reset()
     void resetCycles();

src/dsf/sources/RoadNetwork.cpp

@@ -768,15 +768,14 @@ namespace dsf {
         } else {
           addNode<Intersection>(nodeIndex,
                                 std::make_pair(std::stod(lat), std::stod(lon)));
-          if ((highway.find("in_out") != std::string::npos) ||
-              (highway.find("outgoing_only") != std::string::npos)) {
-            Logger::debug(std::format("Setting node {} as an output node", nodeIndex));
-            m_outputNodes.push_back(nodeIndex);
+          if (highway.find("destination") != std::string::npos) {
+            Logger::debug(
+                std::format("Setting node {} as a destination node", nodeIndex));
+            m_destinationNodes.push_back(nodeIndex);
           }
-          if ((highway.find("in_out") != std::string::npos) ||
-              (highway.find("ingoing_only") != std::string::npos)) {
-            Logger::debug(std::format("Setting node {} as an input node", nodeIndex));
-            m_inputNodes.push_back(nodeIndex);
+          if (highway.find("origin") != std::string::npos) {
+            Logger::debug(std::format("Setting node {} as an origin node", nodeIndex));
+            m_originNodes.push_back(nodeIndex);
           }
         }
         m_nodeMapping.emplace(std::make_pair(id, nodeIndex));
@@ -1056,11 +1055,13 @@ namespace dsf {
         file << ";traffic_light";
       } else if (pNode->isRoundabout()) {
         file << ";roundabout";
-      } else if (std::find(m_inputNodes.begin(), m_inputNodes.end(), nodeId) !=
-                     m_inputNodes.end() ||
-                 std::find(m_outputNodes.begin(), m_outputNodes.end(), nodeId) !=
-                     m_outputNodes.end()) {
-        file << ";io";
+      } else if (std::find(m_originNodes.begin(), m_originNodes.end(), nodeId) !=
+                 m_originNodes.end()) {
+        file << ";origin";
+      } else if (std::find(m_destinationNodes.begin(),
+                           m_destinationNodes.end(),
+                           nodeId) != m_destinationNodes.end()) {
+        file << ";destination";
       } else {
         file << ";";
       }

src/dsf/sources/TrafficLight.cpp

@@ -71,38 +71,6 @@ namespace dsf {
     return *this;
   }
 
-  Delay TrafficLight::maxGreenTime(bool priorityStreets) const {
-    Delay maxTime{0};
-    for (auto const& [streetId, cycles] : m_cycles) {
-      if (priorityStreets && m_streetPriorities.contains(streetId)) {
-        for (auto const& [direction, cycle] : cycles) {
-          maxTime = std::max(maxTime, cycle.greenTime());
-        }
-      } else {
-        for (auto const& [direction, cycle] : cycles) {
-          maxTime = std::max(maxTime, cycle.greenTime());
-        }
-      }
-    }
-    return maxTime;
-  }
-
-  Delay TrafficLight::minGreenTime(bool priorityStreets) const {
-    Delay minTime{std::numeric_limits<Delay>::max()};
-    for (auto const& [streetId, cycles] : m_cycles) {
-      if (priorityStreets && m_streetPriorities.contains(streetId)) {
-        for (auto const& [direction, cycle] : cycles) {
-          minTime = std::min(minTime, cycle.greenTime());
-        }
-      } else {
-        for (auto const& [direction, cycle] : cycles) {
-          minTime = std::min(minTime, cycle.greenTime());
-        }
-      }
-    }
-    return minTime;
-  }
-
   double TrafficLight::meanGreenTime(bool priorityStreets) const {
     double meanTime{0.};
     size_t nCycles{0};
@@ -123,20 +91,6 @@ namespace dsf {
     return meanTime / nCycles;
   }
 
-  void TrafficLight::increaseGreenTimes(Delay const delta) {
-    for (auto& [streetId, cycles] : m_cycles) {
-      if (m_streetPriorities.contains(streetId)) {
-        for (auto& [direction, cycle] : cycles) {
-          cycle = TrafficLightCycle(cycle.greenTime() + delta, cycle.phase());
-        }
-      } else {
-        for (auto& [direction, cycle] : cycles) {
-          cycle = TrafficLightCycle(cycle.greenTime() - delta, cycle.phase() + delta);
-        }
-      }
-    }
-  }
-
   void TrafficLight::increasePhases(Delay const phase) {
     for (auto& [streetId, cycles] : m_cycles) {
       for (auto& [direction, cycle] : cycles) {
@@ -147,20 +101,6 @@ namespace dsf {
     }
   }
 
-  void TrafficLight::decreaseGreenTimes(Delay const delta) {
-    for (auto& [streetId, cycles] : m_cycles) {
-      if (!m_streetPriorities.contains(streetId)) {
-        for (auto& [direction, cycle] : cycles) {
-          cycle = TrafficLightCycle(cycle.greenTime() + delta, cycle.phase());
-        }
-      } else {
-        for (auto& [direction, cycle] : cycles) {
-          cycle = TrafficLightCycle(cycle.greenTime() - delta, cycle.phase() + delta);
-        }
-      }
-    }
-  }
-
   bool TrafficLight::isDefault() const {
     for (auto const& [streetId, cycles] : m_cycles) {
       for (auto const& [direction, cycle] : cycles) {
@@ -228,20 +168,6 @@ namespace dsf {
     return m_cycles.at(streetId).at(direction).isGreen(m_cycleTime, m_counter);
   }
 
-  bool TrafficLight::isFavouringDirection(bool const priority) const {
-    for (auto const& [streetId, cycles] : m_cycles) {
-      if ((priority && m_streetPriorities.contains(streetId)) ||
-          (!priority && !m_streetPriorities.contains(streetId))) {
-        for (auto const& [direction, cycle] : cycles) {
-          if (!cycle.isGreenTimeIncreased()) {
-            return false;
-          }
-        }
-      }
-    }
-    return true;
-  }
-
   void TrafficLight::resetCycles() {
     m_defaultCycles.empty() ? m_defaultCycles = m_cycles : m_cycles = m_defaultCycles;
   }