Make forward/reverse weight/offset calculated at query time,

rather than being cached in the StaticRTree.  This means we
can freely apply traffic data and not have stale values lying
around.  It reduces the size of the RTree on disk, at the expense
of some additional data in RAM.

include/engine/datafacade/datafacade_base.hpp

@@ -69,8 +69,13 @@ template <class EdgeDataT> class BaseDataFacade
 
     virtual unsigned GetGeometryIndexForEdgeID(const unsigned id) const = 0;
 
-    virtual void GetUncompressedGeometry(const unsigned id,
-                                         std::vector<unsigned> &result_nodes) const = 0;
+    virtual void GetUncompressedGeometry(const EdgeID id,
+                                         std::vector<NodeID> &result_nodes) const = 0;
+
+    // Gets the weight values for each segment in an uncompressed geometry.
+    // Should always be 1 shorter than GetUncompressedGeometry
+    virtual void GetUncompressedWeights(const EdgeID id,
+                                         std::vector<EdgeWeight> &result_weights) const = 0;
 
     virtual extractor::TurnInstruction GetTurnInstructionForEdgeID(const unsigned id) const = 0;
 

include/engine/datafacade/internal_datafacade.hpp

@@ -16,6 +16,7 @@
 #include "util/graph_loader.hpp"
 #include "util/simple_logger.hpp"
 #include "util/rectangle.hpp"
+#include "extractor/compressed_edge_container.hpp"
 
 #include "osrm/coordinate.hpp"
 
@@ -55,7 +56,7 @@ template <class EdgeDataT> class InternalDataFacade final : public BaseDataFacad
     using RTreeLeaf = typename super::RTreeLeaf;
     using InternalRTree =
         util::StaticRTree<RTreeLeaf, util::ShM<util::FixedPointCoordinate, false>::vector, false>;
-    using InternalGeospatialQuery = GeospatialQuery<InternalRTree>;
+    using InternalGeospatialQuery = GeospatialQuery<InternalRTree, BaseDataFacade<EdgeDataT>>;
 
     InternalDataFacade() {}
 
@@ -72,8 +73,9 @@ template <class EdgeDataT> class InternalDataFacade final : public BaseDataFacad
     util::ShM<char, false>::vector m_names_char_list;
     util::ShM<bool, false>::vector m_edge_is_compressed;
     util::ShM<unsigned, false>::vector m_geometry_indices;
-    util::ShM<unsigned, false>::vector m_geometry_list;
+    util::ShM<extractor::CompressedEdgeContainer::CompressedEdge, false>::vector m_geometry_list;
     util::ShM<bool, false>::vector m_is_core_node;
+    util::ShM<unsigned, false>::vector m_segment_weights;
 
     boost::thread_specific_ptr<InternalRTree> m_static_rtree;
     boost::thread_specific_ptr<InternalGeospatialQuery> m_geospatial_query;
@@ -220,7 +222,7 @@ template <class EdgeDataT> class InternalDataFacade final : public BaseDataFacad
         if (number_of_compressed_geometries > 0)
         {
             geometry_stream.read((char *)&(m_geometry_list[0]),
-                                 number_of_compressed_geometries * sizeof(unsigned));
+                                 number_of_compressed_geometries * sizeof(extractor::CompressedEdgeContainer::CompressedEdge));
         }
         geometry_stream.close();
     }
@@ -230,7 +232,7 @@ template <class EdgeDataT> class InternalDataFacade final : public BaseDataFacad
         BOOST_ASSERT_MSG(!m_coordinate_list->empty(), "coordinates must be loaded before r-tree");
 
         m_static_rtree.reset(new InternalRTree(ram_index_path, file_index_path, m_coordinate_list));
-        m_geospatial_query.reset(new InternalGeospatialQuery(*m_static_rtree, m_coordinate_list));
+        m_geospatial_query.reset(new InternalGeospatialQuery(*m_static_rtree, m_coordinate_list, *this));
     }
 
     void LoadStreetNames(const boost::filesystem::path &names_file)
@@ -464,15 +466,27 @@ template <class EdgeDataT> class InternalDataFacade final : public BaseDataFacad
         }
     }
 
-    virtual void GetUncompressedGeometry(const unsigned id,
-                                         std::vector<unsigned> &result_nodes) const override final
+    virtual void GetUncompressedGeometry(const EdgeID id,
+                                         std::vector<NodeID> &result_nodes) const override final
     {
         const unsigned begin = m_geometry_indices.at(id);
         const unsigned end = m_geometry_indices.at(id + 1);
 
         result_nodes.clear();
-        result_nodes.insert(result_nodes.begin(), m_geometry_list.begin() + begin,
-                            m_geometry_list.begin() + end);
+        result_nodes.reserve(end - begin);
+        std::for_each(m_geometry_list.begin() + begin, m_geometry_list.begin() + end, [&](const osrm::extractor::CompressedEdgeContainer::CompressedEdge &edge){ result_nodes.emplace_back(edge.node_id); });
+    }
+
+    virtual void GetUncompressedWeights(const EdgeID id,
+                                        std::vector<EdgeWeight> &result_weights) const override final
+    {
+        const unsigned begin = m_geometry_indices.at(id);
+        const unsigned end = m_geometry_indices.at(id + 1);
+
+        result_weights.clear();
+        result_weights.reserve(end - begin);
+        std::for_each(m_geometry_list.begin() + begin, m_geometry_list.begin() + end, [&](const osrm::extractor::CompressedEdgeContainer::CompressedEdge &edge){ result_weights.emplace_back(edge.weight); });
+
     }
 
     std::string GetTimestamp() const override final { return m_timestamp; }

include/engine/datafacade/shared_datafacade.hpp

@@ -50,7 +50,7 @@ template <class EdgeDataT> class SharedDataFacade final : public BaseDataFacade<
     using RTreeLeaf = typename super::RTreeLeaf;
     using SharedRTree =
         util::StaticRTree<RTreeLeaf, util::ShM<util::FixedPointCoordinate, true>::vector, true>;
-    using SharedGeospatialQuery = GeospatialQuery<SharedRTree>;
+    using SharedGeospatialQuery = GeospatialQuery<SharedRTree, BaseDataFacade<EdgeDataT>>;
     using TimeStampedRTreePair = std::pair<unsigned, std::shared_ptr<SharedRTree>>;
     using RTreeNode = typename SharedRTree::TreeNode;
 
@@ -77,7 +77,7 @@ template <class EdgeDataT> class SharedDataFacade final : public BaseDataFacade<
     util::ShM<unsigned, true>::vector m_name_begin_indices;
     util::ShM<bool, true>::vector m_edge_is_compressed;
     util::ShM<unsigned, true>::vector m_geometry_indices;
-    util::ShM<unsigned, true>::vector m_geometry_list;
+    util::ShM<extractor::CompressedEdgeContainer::CompressedEdge, true>::vector m_geometry_list;
     util::ShM<bool, true>::vector m_is_core_node;
 
     boost::thread_specific_ptr<std::pair<unsigned, std::shared_ptr<SharedRTree>>> m_static_rtree;
@@ -115,7 +115,7 @@ template <class EdgeDataT> class SharedDataFacade final : public BaseDataFacade<
                 tree_ptr, data_layout->num_entries[storage::SharedDataLayout::R_SEARCH_TREE],
                 file_index_path, m_coordinate_list)));
         m_geospatial_query.reset(
-            new SharedGeospatialQuery(*m_static_rtree->second, m_coordinate_list));
+            new SharedGeospatialQuery(*m_static_rtree->second, m_coordinate_list, *this));
     }
 
     void LoadGraph()
@@ -221,9 +221,10 @@ template <class EdgeDataT> class SharedDataFacade final : public BaseDataFacade<
             data_layout->num_entries[storage::SharedDataLayout::GEOMETRIES_INDEX]);
         m_geometry_indices = std::move(geometry_begin_indices);
 
-        auto geometries_list_ptr = data_layout->GetBlockPtr<unsigned>(
-            shared_memory, storage::SharedDataLayout::GEOMETRIES_LIST);
-        typename util::ShM<unsigned, true>::vector geometry_list(
+        auto geometries_list_ptr =
+            data_layout->GetBlockPtr<extractor::CompressedEdgeContainer::CompressedEdge>(
+                    shared_memory, storage::SharedDataLayout::GEOMETRIES_LIST);
+        typename util::ShM<extractor::CompressedEdgeContainer::CompressedEdge, true>::vector geometry_list(
             geometries_list_ptr,
             data_layout->num_entries[storage::SharedDataLayout::GEOMETRIES_LIST]);
         m_geometry_list = std::move(geometry_list);
@@ -382,15 +383,27 @@ template <class EdgeDataT> class SharedDataFacade final : public BaseDataFacade<
         return m_edge_is_compressed.at(id);
     }
 
-    virtual void GetUncompressedGeometry(const unsigned id,
-                                         std::vector<unsigned> &result_nodes) const override final
+    virtual void GetUncompressedGeometry(const EdgeID id,
+                                         std::vector<NodeID> &result_nodes) const override final
     {
         const unsigned begin = m_geometry_indices.at(id);
         const unsigned end = m_geometry_indices.at(id + 1);
 
         result_nodes.clear();
-        result_nodes.insert(result_nodes.begin(), m_geometry_list.begin() + begin,
-                            m_geometry_list.begin() + end);
+        result_nodes.reserve(end - begin);
+        std::for_each(m_geometry_list.begin() + begin, m_geometry_list.begin() + end, [&](const osrm::extractor::CompressedEdgeContainer::CompressedEdge &edge){ result_nodes.emplace_back(edge.node_id); });
+    }
+
+    virtual void GetUncompressedWeights(const EdgeID id,
+                                        std::vector<EdgeWeight> &result_weights) const override final
+    {
+        const unsigned begin = m_geometry_indices.at(id);
+        const unsigned end = m_geometry_indices.at(id + 1);
+
+        result_weights.clear();
+        result_weights.reserve(end - begin);
+        std::for_each(m_geometry_list.begin() + begin, m_geometry_list.begin() + end, [&](const osrm::extractor::CompressedEdgeContainer::CompressedEdge &edge){ result_weights.emplace_back(edge.weight); });
+
     }
 
     virtual unsigned GetGeometryIndexForEdgeID(const unsigned id) const override final

include/engine/geospatial_query.hpp

@@ -22,14 +22,14 @@ namespace engine
 // Implements complex queries on top of an RTree and builds PhantomNodes from it.
 //
 // Only holds a weak reference on the RTree!
-template <typename RTreeT> class GeospatialQuery
+template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
 {
     using EdgeData = typename RTreeT::EdgeData;
     using CoordinateList = typename RTreeT::CoordinateList;
 
   public:
-    GeospatialQuery(RTreeT &rtree_, std::shared_ptr<CoordinateList> coordinates_)
-        : rtree(rtree_), coordinates(std::move(coordinates_))
+    GeospatialQuery(RTreeT &rtree_, std::shared_ptr<CoordinateList> coordinates_, DataFacadeT &datafacade_)
+        : rtree(rtree_), coordinates(std::move(coordinates_)), datafacade(datafacade_)
     {
     }
 
@@ -150,19 +150,51 @@ template <typename RTreeT> class GeospatialQuery
                 coordinates->at(data.u), coordinates->at(data.v), input_coordinate,
                 point_on_segment, ratio);
 
-        auto transformed = PhantomNodeWithDistance{PhantomNode{data, point_on_segment},
-                                                   current_perpendicular_distance};
+        // Find the node-based-edge that this belongs to, and directly
+        // calculate the forward_weight, forward_offset, reverse_weight, reverse_offset
+
+        int forward_offset = 0, forward_weight = 0;
+        int reverse_offset = 0, reverse_weight = 0;
+
+        if (data.forward_packed_geometry_id != SPECIAL_EDGEID) {
+            std::vector<EdgeWeight> forward_weight_vector;
+            datafacade.GetUncompressedWeights(data.forward_packed_geometry_id,
+                                            forward_weight_vector);
+            for (std::size_t i = 0; i < data.fwd_segment_position; i++)
+            {
+                forward_offset += forward_weight_vector[i];
+            }
+            forward_weight = forward_weight_vector[data.fwd_segment_position];
+        }
+
+        if (data.reverse_packed_geometry_id != SPECIAL_EDGEID) {
+            std::vector<EdgeWeight> reverse_weight_vector;
+            datafacade.GetUncompressedWeights(data.reverse_packed_geometry_id,
+                                              reverse_weight_vector);
+
+            //BOOST_ASSERT(reverse_weight_vector.size() == forward_weight_vector.size());
+            BOOST_ASSERT(data.fwd_segment_position < reverse_weight_vector.size());
+
+            for (std::size_t i = 0; i < reverse_weight_vector.size() - data.fwd_segment_position - 1; i++)
+            {
+                reverse_offset += reverse_weight_vector[i];
+            }
+            reverse_weight = reverse_weight_vector[reverse_weight_vector.size() -
+                                                   data.fwd_segment_position - 1];
+        }
 
         ratio = std::min(1.0, std::max(0.0, ratio));
+        if (SPECIAL_NODEID != data.forward_edge_based_node_id) {
+            forward_weight *= ratio;
+        }
+        if (SPECIAL_NODEID != data.reverse_edge_based_node_id) {
+            reverse_weight *= 1.0 - ratio;
+        }
+
+        auto transformed = PhantomNodeWithDistance{PhantomNode{data, forward_weight, forward_offset,
+            reverse_weight, reverse_offset, point_on_segment},
+                                                   current_perpendicular_distance};
 
-        if (SPECIAL_NODEID != transformed.phantom_node.forward_node_id)
-        {
-            transformed.phantom_node.forward_weight *= ratio;
-        }
-        if (SPECIAL_NODEID != transformed.phantom_node.reverse_node_id)
-        {
-            transformed.phantom_node.reverse_weight *= 1.0 - ratio;
-        }
         return transformed;
     }
 
@@ -190,6 +222,7 @@ template <typename RTreeT> class GeospatialQuery
 
     RTreeT &rtree;
     const std::shared_ptr<CoordinateList> coordinates;
+    DataFacadeT &datafacade;
 };
 }
 }

include/engine/phantom_node.hpp

@@ -24,7 +24,8 @@ struct PhantomNode
                 int reverse_weight,
                 int forward_offset,
                 int reverse_offset,
-                unsigned packed_geometry_id,
+                unsigned forward_packed_geometry_id_,
+                unsigned reverse_packed_geometry_id_,
                 bool is_tiny_component,
                 unsigned component_id,
                 util::FixedPointCoordinate location,
@@ -34,7 +35,9 @@ struct PhantomNode
         : forward_node_id(forward_node_id), reverse_node_id(reverse_node_id), name_id(name_id),
           forward_weight(forward_weight), reverse_weight(reverse_weight),
           forward_offset(forward_offset), reverse_offset(reverse_offset),
-          packed_geometry_id(packed_geometry_id), component{component_id, is_tiny_component},
+          forward_packed_geometry_id(forward_packed_geometry_id_),
+          reverse_packed_geometry_id(reverse_packed_geometry_id_),
+          component{component_id, is_tiny_component},
           location(std::move(location)), fwd_segment_position(fwd_segment_position),
           forward_travel_mode(forward_travel_mode), backward_travel_mode(backward_travel_mode)
     {
@@ -44,7 +47,9 @@ struct PhantomNode
         : forward_node_id(SPECIAL_NODEID), reverse_node_id(SPECIAL_NODEID),
           name_id(std::numeric_limits<unsigned>::max()), forward_weight(INVALID_EDGE_WEIGHT),
           reverse_weight(INVALID_EDGE_WEIGHT), forward_offset(0), reverse_offset(0),
-          packed_geometry_id(SPECIAL_EDGEID), component{INVALID_COMPONENTID, false},
+          forward_packed_geometry_id(SPECIAL_EDGEID),
+          reverse_packed_geometry_id(SPECIAL_EDGEID),
+          component{INVALID_COMPONENTID, false},
           fwd_segment_position(0), forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
           backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
     {
@@ -89,19 +94,20 @@ struct PhantomNode
     bool operator==(const PhantomNode &other) const { return location == other.location; }
 
     template <class OtherT>
-    PhantomNode(const OtherT &other, const util::FixedPointCoordinate foot_point)
+    PhantomNode(const OtherT &other, int forward_weight_, int forward_offset_, int reverse_weight_, int reverse_offset_, const util::FixedPointCoordinate foot_point)
     {
         forward_node_id = other.forward_edge_based_node_id;
         reverse_node_id = other.reverse_edge_based_node_id;
         name_id = other.name_id;
 
-        forward_weight = other.forward_weight;
-        reverse_weight = other.reverse_weight;
+        forward_weight = forward_weight_;
+        reverse_weight = reverse_weight_;
 
-        forward_offset = other.forward_offset;
-        reverse_offset = other.reverse_offset;
+        forward_offset = forward_offset_;
+        reverse_offset = reverse_offset_;
 
-        packed_geometry_id = other.packed_geometry_id;
+        forward_packed_geometry_id = other.forward_packed_geometry_id;
+        reverse_packed_geometry_id = other.reverse_packed_geometry_id;
 
         component.id = other.component.id;
         component.is_tiny = other.component.is_tiny;
@@ -120,7 +126,8 @@ struct PhantomNode
     int reverse_weight;
     int forward_offset;
     int reverse_offset;
-    unsigned packed_geometry_id;
+    unsigned forward_packed_geometry_id;
+    unsigned reverse_packed_geometry_id;
     struct ComponentType
     {
         uint32_t id : 31;
@@ -139,7 +146,7 @@ struct PhantomNode
 };
 
 #ifndef _MSC_VER
-static_assert(sizeof(PhantomNode) == 48, "PhantomNode has more padding then expected");
+static_assert(sizeof(PhantomNode) == 52, "PhantomNode has more padding then expected");
 #endif
 
 using PhantomNodePair = std::pair<PhantomNode, PhantomNode>;
@@ -172,7 +179,8 @@ inline std::ostream &operator<<(std::ostream &out, const PhantomNode &pn)
         << "rev-w: " << pn.reverse_weight << ", "
         << "fwd-o: " << pn.forward_offset << ", "
         << "rev-o: " << pn.reverse_offset << ", "
-        << "geom: " << pn.packed_geometry_id << ", "
+        << "fwd_geom: " << pn.forward_packed_geometry_id << ", "
+        << "rev_geom: " << pn.reverse_packed_geometry_id << ", "
         << "comp: " << pn.component.is_tiny << " / " << pn.component.id << ", "
         << "pos: " << pn.fwd_segment_position << ", "
         << "loc: " << pn.location;

include/engine/plugins/tile.hpp

@@ -244,12 +244,34 @@ template <class DataFacadeT> class TilePlugin final : public BasePlugin
                     // Get coordinates for start/end nodes of segmet (NodeIDs u and v)
                     const auto a = facade->GetCoordinateOfNode(edge.u);
                     const auto b = facade->GetCoordinateOfNode(edge.v);
-                    // Calculate the length in meters
-                    const double length = osrm::util::coordinate_calculation::haversineDistance(
-                        a.lon, a.lat, b.lon, b.lat);
+                    // Calculate the length in meters, using the same calculation used to set the
+                    // weight, so we can back-calculate the speed value that was set.
+                    const double length = osrm::util::coordinate_calculation::greatCircleDistance(
+                        a.lat, a.lon, b.lat, b.lon);
+
+                    int forward_weight = 0;
+                    int reverse_weight = 0;
+
+                    if (edge.forward_packed_geometry_id != SPECIAL_EDGEID) {
+                        std::vector<EdgeWeight> forward_weight_vector;
+                        facade->GetUncompressedWeights(edge.forward_packed_geometry_id,
+                                                          forward_weight_vector);
+                        forward_weight = forward_weight_vector[edge.fwd_segment_position];
+                    }
+
+                    if (edge.reverse_packed_geometry_id != SPECIAL_EDGEID) {
+                        std::vector<EdgeWeight> reverse_weight_vector;
+                        facade->GetUncompressedWeights(edge.reverse_packed_geometry_id,
+                                                          reverse_weight_vector);
+
+                        BOOST_ASSERT(edge.fwd_segment_position < reverse_weight_vector.size());
+
+                        reverse_weight = reverse_weight_vector[reverse_weight_vector.size() -
+                                                               edge.fwd_segment_position - 1];
+                    }
 
                     // If this is a valid forward edge, go ahead and add it to the tile
-                    if (edge.forward_weight != 0 &&
+                    if (forward_weight != 0 &&
                         edge.forward_edge_based_node_id != SPECIAL_NODEID)
                     {
                         std::int32_t start_x = 0;
@@ -263,7 +285,7 @@ template <class DataFacadeT> class TilePlugin final : public BasePlugin
 
                         // Calculate the speed for this line
                         std::uint32_t speed = static_cast<std::uint32_t>(
-                            round(length / edge.forward_weight * 10 * 3.6));
+                            round(length / forward_weight * 10 * 3.6));
 
                         line_type tile_line;
                         for (auto const &pt : geo_line)
@@ -315,7 +337,7 @@ template <class DataFacadeT> class TilePlugin final : public BasePlugin
 
                     // Repeat the above for the coordinates reversed and using the `reverse`
                     // properties
-                    if (edge.reverse_weight != 0 &&
+                    if (reverse_weight != 0 &&
                         edge.reverse_edge_based_node_id != SPECIAL_NODEID)
                     {
                         std::int32_t start_x = 0;
@@ -328,7 +350,7 @@ template <class DataFacadeT> class TilePlugin final : public BasePlugin
                                               a.lat / COORDINATE_PRECISION);
 
                         const auto speed = static_cast<const std::uint32_t>(
-                            round(length / edge.forward_weight * 10 * 3.6));
+                            round(length / reverse_weight * 10 * 3.6));
 
                         line_type tile_line;
                         for (auto const &pt : geo_line)

include/engine/routing_algorithms/routing_base.hpp

@@ -17,6 +17,7 @@
 #include <utility>
 #include <vector>
 #include <stack>
+#include <numeric>
 
 namespace osrm
 {
@@ -302,10 +303,20 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
                 }
                 else
                 {
-                    std::vector<unsigned> id_vector;
+                    std::vector<NodeID> id_vector;
                     facade->GetUncompressedGeometry(facade->GetGeometryIndexForEdgeID(ed.id),
                                                     id_vector);
 
+                    std::vector<EdgeWeight> weight_vector;
+                    facade->GetUncompressedWeights(facade->GetGeometryIndexForEdgeID(ed.id),
+                                                   weight_vector);
+
+                    int total_weight = std::accumulate(weight_vector.begin(), weight_vector.end(), 0);
+
+                    BOOST_ASSERT(weight_vector.size() == id_vector.size());
+                    // ed.distance should be total_weight + penalties (turn, stop, etc)
+                    BOOST_ASSERT(ed.distance >= total_weight);
+
                     const std::size_t start_index =
                         (unpacked_path.empty()
                              ? ((start_traversed_in_reverse)
@@ -320,58 +331,57 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
                     for (std::size_t i = start_index; i < end_index; ++i)
                     {
                         unpacked_path.emplace_back(id_vector[i], name_index,
-                                                   extractor::TurnInstruction::NoTurn, 0,
+                                                   extractor::TurnInstruction::NoTurn, weight_vector[i],
                                                    travel_mode);
                     }
                     unpacked_path.back().turn_instruction = turn_instruction;
-                    unpacked_path.back().segment_duration = ed.distance;
+                    unpacked_path.back().segment_duration += (ed.distance - total_weight);
                 }
             }
         }
-        if (SPECIAL_EDGEID != phantom_node_pair.target_phantom.packed_geometry_id)
+        std::vector<unsigned> id_vector;
+        facade->GetUncompressedGeometry(phantom_node_pair.target_phantom.forward_packed_geometry_id,
+                                        id_vector);
+        const bool is_local_path = (phantom_node_pair.source_phantom.forward_packed_geometry_id ==
+                                    phantom_node_pair.target_phantom.forward_packed_geometry_id) &&
+                                    unpacked_path.empty();
+
+        std::cout << "Got id vector of size " << id_vector.size() << "\n";
+
+        std::size_t start_index = 0;
+        if (is_local_path)
         {
-            std::vector<unsigned> id_vector;
-            facade->GetUncompressedGeometry(phantom_node_pair.target_phantom.packed_geometry_id,
-                                            id_vector);
-            const bool is_local_path = (phantom_node_pair.source_phantom.packed_geometry_id ==
-                                        phantom_node_pair.target_phantom.packed_geometry_id) &&
-                                       unpacked_path.empty();
-
-            std::size_t start_index = 0;
-            if (is_local_path)
-            {
-                start_index = phantom_node_pair.source_phantom.fwd_segment_position;
-                if (target_traversed_in_reverse)
-                {
-                    start_index =
-                        id_vector.size() - phantom_node_pair.source_phantom.fwd_segment_position;
-                }
-            }
-
-            std::size_t end_index = phantom_node_pair.target_phantom.fwd_segment_position;
+            start_index = phantom_node_pair.source_phantom.fwd_segment_position;
             if (target_traversed_in_reverse)
             {
-                std::reverse(id_vector.begin(), id_vector.end());
-                end_index =
-                    id_vector.size() - phantom_node_pair.target_phantom.fwd_segment_position;
+                start_index =
+                    id_vector.size() - phantom_node_pair.source_phantom.fwd_segment_position;
             }
+        }
 
-            if (start_index > end_index)
-            {
-                start_index = std::min(start_index, id_vector.size() - 1);
-            }
+        std::size_t end_index = phantom_node_pair.target_phantom.fwd_segment_position;
+        if (target_traversed_in_reverse)
+        {
+            std::reverse(id_vector.begin(), id_vector.end());
+            end_index =
+                id_vector.size() - phantom_node_pair.target_phantom.fwd_segment_position;
+        }
 
-            for (std::size_t i = start_index; i != end_index; (start_index < end_index ? ++i : --i))
-            {
-                BOOST_ASSERT(i < id_vector.size());
-                BOOST_ASSERT(phantom_node_pair.target_phantom.forward_travel_mode > 0);
-                unpacked_path.emplace_back(
-                    PathData{id_vector[i], phantom_node_pair.target_phantom.name_id,
-                             extractor::TurnInstruction::NoTurn, 0,
-                             target_traversed_in_reverse
-                                 ? phantom_node_pair.target_phantom.backward_travel_mode
-                                 : phantom_node_pair.target_phantom.forward_travel_mode});
-            }
+        if (start_index > end_index)
+        {
+            start_index = std::min(start_index, id_vector.size() - 1);
+        }
+
+        for (std::size_t i = start_index; i != end_index; (start_index < end_index ? ++i : --i))
+        {
+            BOOST_ASSERT(i < id_vector.size());
+            BOOST_ASSERT(phantom_node_pair.target_phantom.forward_travel_mode > 0);
+            unpacked_path.emplace_back(
+                PathData{id_vector[i], phantom_node_pair.target_phantom.name_id,
+                         extractor::TurnInstruction::NoTurn, 0,
+                         target_traversed_in_reverse
+                             ? phantom_node_pair.target_phantom.backward_travel_mode
+                             : phantom_node_pair.target_phantom.forward_travel_mode});
         }
 
         // there is no equivalent to a node-based node in an edge-expanded graph.