Add option to set segments as non-snapable from lua

data_structures/import_edge.cpp

@@ -50,7 +50,7 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &other) const
 NodeBasedEdge::NodeBasedEdge()
     : source(SPECIAL_NODEID), target(SPECIAL_NODEID), name_id(0), weight(0), forward(false),
       backward(false), roundabout(false),
-      access_restricted(false), is_split(false), travel_mode(false)
+      access_restricted(false), startpoint(true), is_split(false), travel_mode(false)
 {
 }
 
@@ -62,11 +62,12 @@ NodeBasedEdge::NodeBasedEdge(NodeID source,
                              bool backward,
                              bool roundabout,
                              bool access_restricted,
+                             bool startpoint,
                              TravelMode travel_mode,
                              bool is_split)
     : source(source), target(target), name_id(name_id), weight(weight), forward(forward),
       backward(backward), roundabout(roundabout),
-      access_restricted(access_restricted), is_split(is_split), travel_mode(travel_mode)
+      access_restricted(access_restricted), startpoint(startpoint), is_split(is_split), travel_mode(travel_mode)
 {
 }
 

data_structures/import_edge.hpp

@@ -44,6 +44,7 @@ struct NodeBasedEdge
                            bool backward,
                            bool roundabout,
                            bool access_restricted,
+                           bool startpoint,
                            TravelMode travel_mode,
                            bool is_split);
 
@@ -55,6 +56,7 @@ struct NodeBasedEdge
     bool backward : 1;
     bool roundabout : 1;
     bool access_restricted : 1;
+    bool startpoint : 1;
     bool is_split : 1;
     TravelMode travel_mode : 4;
 };
@@ -69,9 +71,10 @@ struct NodeBasedEdgeWithOSM : NodeBasedEdge
                            bool backward,
                            bool roundabout,
                            bool access_restricted,
+                           bool startpoint,
                            TravelMode travel_mode,
                            bool is_split)
-        : NodeBasedEdge(SPECIAL_NODEID, SPECIAL_NODEID, name_id, weight, forward, backward, roundabout, access_restricted, travel_mode, is_split),
+        : NodeBasedEdge(SPECIAL_NODEID, SPECIAL_NODEID, name_id, weight, forward, backward, roundabout, access_restricted, startpoint, travel_mode, is_split),
         osm_source_id(source), osm_target_id(target) {}
 
     OSMNodeID osm_source_id;

data_structures/node_based_graph.hpp

@@ -47,10 +47,10 @@ struct NodeBasedEdgeData
 
     NodeBasedEdgeData(int distance, unsigned edge_id, unsigned name_id,
             bool access_restricted, bool reversed,
-            bool roundabout, TravelMode travel_mode)
+            bool roundabout, bool startpoint, TravelMode travel_mode)
         : distance(distance), edge_id(edge_id), name_id(name_id),
           access_restricted(access_restricted), reversed(reversed),
-          roundabout(roundabout), travel_mode(travel_mode)
+          roundabout(roundabout), startpoint(startpoint), travel_mode(travel_mode)
     {
     }
 
@@ -60,6 +60,7 @@ struct NodeBasedEdgeData
     bool access_restricted : 1;
     bool reversed : 1;
     bool roundabout : 1;
+    bool startpoint : 1;
     TravelMode travel_mode : 4;
 
     bool IsCompatibleTo(const NodeBasedEdgeData &other) const
@@ -72,7 +73,7 @@ struct NodeBasedEdgeData
 using NodeBasedDynamicGraph = DynamicGraph<NodeBasedEdgeData>;
 
 /// Factory method to create NodeBasedDynamicGraph from NodeBasedEdges
-/// The since DynamicGraph expects directed edges, we need to insert
+/// Since DynamicGraph expects directed edges, we need to insert
 /// two edges for undirected edges.
 inline std::shared_ptr<NodeBasedDynamicGraph>
 NodeBasedDynamicGraphFromEdges(std::size_t number_of_nodes, const std::vector<NodeBasedEdge> &input_edge_list)
@@ -87,6 +88,7 @@ NodeBasedDynamicGraphFromEdges(std::size_t number_of_nodes, const std::vector<No
             output_edge.data.name_id = input_edge.name_id;
             output_edge.data.access_restricted = input_edge.access_restricted;
             output_edge.data.travel_mode = input_edge.travel_mode;
+            output_edge.data.startpoint = input_edge.startpoint;
         }
     );
 

extractor/edge_based_graph_factory.cpp

@@ -78,6 +78,11 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodes(std::vector<EdgeBasedNode> &nodes)
     nodes.swap(m_edge_based_node_list);
 }
 
+void EdgeBasedGraphFactory::GetStartPointMarkers(std::vector<bool> &node_is_startpoint)
+{
+    m_edge_based_node_is_startpoint.swap(node_is_startpoint);
+}
+
 unsigned EdgeBasedGraphFactory::GetHighestEdgeID()
 {
     return m_max_edge_id;
@@ -165,6 +170,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
                 reverse_geometry[geometry_size - 1 - i].second, forward_dist_prefix_sum[i],
                 reverse_dist_prefix_sum[i], m_compressed_edge_container.GetPositionForID(edge_id_1),
                 false, INVALID_COMPONENTID, i, forward_data.travel_mode, reverse_data.travel_mode);
+            m_edge_based_node_is_startpoint.push_back(forward_data.startpoint || reverse_data.startpoint);
             current_edge_source_coordinate_id = current_edge_target_coordinate_id;
 
             BOOST_ASSERT(m_edge_based_node_list.back().IsCompressed());
@@ -208,6 +214,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u,
             forward_data.edge_id, reverse_data.edge_id, node_u, node_v,
             forward_data.name_id, forward_data.distance, reverse_data.distance, 0, 0, SPECIAL_EDGEID,
             false, INVALID_COMPONENTID, 0, forward_data.travel_mode, reverse_data.travel_mode);
+        m_edge_based_node_is_startpoint.push_back(forward_data.startpoint || reverse_data.startpoint);
         BOOST_ASSERT(!m_edge_based_node_list.back().IsCompressed());
     }
 }
@@ -336,6 +343,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
         }
     }
 
+    BOOST_ASSERT(m_edge_based_node_list.size() == m_edge_based_node_is_startpoint.size());
+
     SimpleLogger().Write() << "Generated " << m_edge_based_node_list.size()
                            << " nodes in edge-expanded graph";
 }

extractor/edge_based_graph_factory.hpp

@@ -86,6 +86,7 @@ class EdgeBasedGraphFactory
     void GetEdgeBasedEdges(DeallocatingVector<EdgeBasedEdge> &edges);
 
     void GetEdgeBasedNodes(std::vector<EdgeBasedNode> &nodes);
+    void GetStartPointMarkers(std::vector<bool> &node_is_startpoint);
 
     unsigned GetHighestEdgeID();
 
@@ -96,6 +97,9 @@ class EdgeBasedGraphFactory
   private:
     using EdgeData = NodeBasedDynamicGraph::EdgeData;
 
+    //! maps index from m_edge_based_node_list to ture/false if the node is an entry point to the graph
+    std::vector<bool> m_edge_based_node_is_startpoint;
+    //! list of edge based nodes (compressed segments)
     std::vector<EdgeBasedNode> m_edge_based_node_list;
     DeallocatingVector<EdgeBasedEdge> m_edge_based_edge_list;
     unsigned m_max_edge_id;

extractor/extraction_way.hpp

@@ -50,6 +50,7 @@ struct ExtractionWay
         backward_speed = -1;
         duration = -1;
         roundabout = false;
+        is_startpoint = true;
         is_access_restricted = false;
         name.clear();
         forward_travel_mode = TRAVEL_MODE_DEFAULT;
@@ -120,6 +121,7 @@ struct ExtractionWay
     std::string name;
     bool roundabout;
     bool is_access_restricted;
+    bool is_startpoint;
     TravelMode forward_travel_mode : 4;
     TravelMode backward_travel_mode : 4;
 };

extractor/extractor.cpp

@@ -88,7 +88,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * The result of this process are the following files:
  *  .names : Names of all streets, stored as long consecutive string with prefix sum based index
  *  .osrm  : Nodes and edges in a intermediate format that easy to digest for osrm-prepare
- *  .restrictions : Turn restrictions that are used my osrm-prepare to construct the edge-expanded graph
+ *  .restrictions : Turn restrictions that are used my osrm-prepare to construct the edge-expanded
+ * graph
  *
  */
 int extractor::run()
@@ -255,10 +256,8 @@ int extractor::run()
             return 1;
         }
 
-        extraction_containers.PrepareData(config.output_file_name,
+        extraction_containers.PrepareData(config.output_file_name, config.restriction_file_name,
-                                          config.restriction_file_name,
+                                          config.names_file_name, segment_state);
-                                          config.names_file_name,
-                                          segment_state);
 
         TIMER_STOP(extracting);
         SimpleLogger().Write() << "extraction finished after " << TIMER_SEC(extracting) << "s";
@@ -284,11 +283,11 @@ int extractor::run()
 
         std::vector<EdgeBasedNode> node_based_edge_list;
         DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
+        std::vector<bool> node_is_startpoint;
         std::vector<QueryNode> internal_to_external_node_map;
         auto graph_size =
-            BuildEdgeExpandedGraph(internal_to_external_node_map,
+            BuildEdgeExpandedGraph(internal_to_external_node_map, node_based_edge_list,
-                                   node_based_edge_list, 
+                                   node_is_startpoint, edge_based_edge_list);
-                                   edge_based_edge_list);
 
         auto number_of_node_based_nodes = graph_size.first;
         auto max_edge_id = graph_size.second;
@@ -300,7 +299,8 @@ int extractor::run()
 
         FindComponents(max_edge_id, edge_based_edge_list, node_based_edge_list);
 
-        BuildRTree(node_based_edge_list, internal_to_external_node_map);
+        BuildRTree(std::move(node_based_edge_list), std::move(node_is_startpoint),
+                   internal_to_external_node_map);
 
         TIMER_STOP(rtree);
 
@@ -309,12 +309,12 @@ int extractor::run()
 
         WriteEdgeBasedGraph(config.edge_graph_output_path, max_edge_id, edge_based_edge_list);
 
-        SimpleLogger().Write() << "Expansion  : " << (number_of_node_based_nodes / TIMER_SEC(expansion))
+        SimpleLogger().Write() << "Expansion  : "
-                        << " nodes/sec and " << ((max_edge_id + 1) / TIMER_SEC(expansion))
+                               << (number_of_node_based_nodes / TIMER_SEC(expansion))
-                        << " edges/sec";
+                               << " nodes/sec and " << ((max_edge_id + 1) / TIMER_SEC(expansion))
+                               << " edges/sec";
         SimpleLogger().Write() << "To prepare the data for routing, run: "
-                               << "./osrm-prepare " << config.output_file_name
+                               << "./osrm-prepare " << config.output_file_name << std::endl;
-                               << std::endl;
     }
     catch (const std::exception &e)
     {
@@ -329,7 +329,8 @@ int extractor::run()
     \brief Setups scripting environment (lua-scripting)
     Also initializes speed profile.
 */
-void extractor::SetupScriptingEnvironment(lua_State *lua_state, SpeedProfileProperties &speed_profile)
+void extractor::SetupScriptingEnvironment(lua_State *lua_state,
+                                          SpeedProfileProperties &speed_profile)
 {
     // open utility libraries string library;
     luaL_openlibs(lua_state);
@@ -352,8 +353,8 @@ void extractor::SetupScriptingEnvironment(lua_State *lua_state, SpeedProfileProp
         throw osrm::exception(msg.str());
     }
     speed_profile.traffic_signal_penalty = 10 * lua_tointeger(lua_state, -1);
-    SimpleLogger().Write(logDEBUG)
+    SimpleLogger().Write(logDEBUG) << "traffic_signal_penalty: "
-        << "traffic_signal_penalty: " << speed_profile.traffic_signal_penalty;
+                                   << speed_profile.traffic_signal_penalty;
 
     if (0 != luaL_dostring(lua_state, "return u_turn_penalty\n"))
     {
@@ -462,8 +463,8 @@ std::shared_ptr<RestrictionMap> extractor::LoadRestrictionMap()
   */
 std::shared_ptr<NodeBasedDynamicGraph>
 extractor::LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
-                            std::unordered_set<NodeID> &traffic_lights,
+                              std::unordered_set<NodeID> &traffic_lights,
-                            std::vector<QueryNode> &internal_to_external_node_map)
+                              std::vector<QueryNode> &internal_to_external_node_map)
 {
     std::vector<NodeBasedEdge> edge_list;
 
@@ -503,8 +504,9 @@ extractor::LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
 */
 std::pair<std::size_t, std::size_t>
 extractor::BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
-                                std::vector<EdgeBasedNode> &node_based_edge_list,
+                                  std::vector<EdgeBasedNode> &node_based_edge_list,
-                                DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list)
+                                  std::vector<bool> &node_is_startpoint,
+                                  DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list)
 {
     lua_State *lua_state = luaL_newstate();
     luabind::open(lua_state);
@@ -529,32 +531,31 @@ extractor::BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_n
         std::const_pointer_cast<RestrictionMap const>(restriction_map),
         internal_to_external_node_map, speed_profile);
 
-
     compressed_edge_container.SerializeInternalVector(config.geometry_output_path);
 
     edge_based_graph_factory.Run(config.edge_output_path, lua_state,
-            config.edge_segment_lookup_path,
+                                 config.edge_segment_lookup_path, config.edge_penalty_path,
-            config.edge_penalty_path,
+                                 config.generate_edge_lookup
-            config.generate_edge_lookup
 #ifdef DEBUG_GEOMETRY
-            , config.debug_turns_path
+                                 ,
+                                 config.debug_turns_path
 #endif
-            );
+                                 );
     lua_close(lua_state);
 
     edge_based_graph_factory.GetEdgeBasedEdges(edge_based_edge_list);
     edge_based_graph_factory.GetEdgeBasedNodes(node_based_edge_list);
+    edge_based_graph_factory.GetStartPointMarkers(node_is_startpoint);
     auto max_edge_id = edge_based_graph_factory.GetHighestEdgeID();
 
     const std::size_t number_of_node_based_nodes = node_based_graph->GetNumberOfNodes();
     return std::make_pair(number_of_node_based_nodes, max_edge_id);
 }
 
-
 /**
   \brief Writing info on original (node-based) nodes
  */
-void extractor::WriteNodeMapping(const std::vector<QueryNode> & internal_to_external_node_map)
+void extractor::WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map)
 {
     boost::filesystem::ofstream node_stream(config.node_output_path, std::ios::binary);
     const unsigned size_of_mapping = internal_to_external_node_map.size();
@@ -572,26 +573,44 @@ void extractor::WriteNodeMapping(const std::vector<QueryNode> & internal_to_exte
 
     Saves tree into '.ramIndex' and leaves into '.fileIndex'.
  */
-void extractor::BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list,
+void extractor::BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list,
+                           std::vector<bool> node_is_startpoint,
                            const std::vector<QueryNode> &internal_to_external_node_map)
 {
     SimpleLogger().Write() << "constructing r-tree of " << node_based_edge_list.size()
-                           << " edge elements build on-top of " << internal_to_external_node_map.size()
+                           << " edge elements build on-top of "
-                           << " coordinates";
+                           << internal_to_external_node_map.size() << " coordinates";
+
+    BOOST_ASSERT(node_is_startpoint.size() == node_based_edge_list.size());
+
+    // Filter node based edges based on startpoint
+    auto out_iter = node_based_edge_list.begin();
+    auto in_iter = node_based_edge_list.begin();
+    for (auto index : osrm::irange<std::size_t>(0, node_is_startpoint.size()))
+    {
+        BOOST_ASSERT(in_iter != node_based_edge_list.end());
+        if (node_is_startpoint[index])
+        {
+            *out_iter = *in_iter;
+            out_iter++;
+        }
+        in_iter++;
+    }
+    auto new_size = out_iter - node_based_edge_list.begin();
+    node_based_edge_list.resize(new_size);
 
     TIMER_START(construction);
     StaticRTree<EdgeBasedNode>(node_based_edge_list, config.rtree_nodes_output_path,
-                               config.rtree_leafs_output_path,
+                               config.rtree_leafs_output_path, internal_to_external_node_map);
-                               internal_to_external_node_map);
 
     TIMER_STOP(construction);
     SimpleLogger().Write() << "finished r-tree construction in " << TIMER_SEC(construction)
                            << " seconds";
 }
 
-void extractor::WriteEdgeBasedGraph(std::string const &output_file_filename, 
+void extractor::WriteEdgeBasedGraph(std::string const &output_file_filename,
-                                    size_t const max_edge_id, 
+                                    size_t const max_edge_id,
-                                    DeallocatingVector<EdgeBasedEdge> const & edge_based_edge_list) 
+                                    DeallocatingVector<EdgeBasedEdge> const &edge_based_edge_list)
 {
 
     std::ofstream file_out_stream;
@@ -606,8 +625,9 @@ void extractor::WriteEdgeBasedGraph(std::string const &output_file_filename,
     file_out_stream.write((char *)&number_of_used_edges, sizeof(size_t));
     file_out_stream.write((char *)&max_edge_id, sizeof(size_t));
 
-    for (const auto& edge : edge_based_edge_list) {
+    for (const auto &edge : edge_based_edge_list)
-        file_out_stream.write((char *) &edge, sizeof(EdgeBasedEdge));
+    {
+        file_out_stream.write((char *)&edge, sizeof(EdgeBasedEdge));
     }
 
     TIMER_STOP(write_edges);
@@ -615,5 +635,4 @@ void extractor::WriteEdgeBasedGraph(std::string const &output_file_filename,
 
     SimpleLogger().Write() << "Processed " << number_of_used_edges << " edges";
     file_out_stream.close();
-
 }

extractor/extractor.hpp

@@ -34,29 +34,33 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 class extractor
 {
-public:
+  public:
-  extractor(ExtractorConfig extractor_config) : config(std::move(extractor_config)) {}
+    extractor(ExtractorConfig extractor_config) : config(std::move(extractor_config)) {}
     int run();
-private:
+
+  private:
     ExtractorConfig config;
-    void SetupScriptingEnvironment(lua_State *myLuaState,
+    void SetupScriptingEnvironment(lua_State *myLuaState, SpeedProfileProperties &speed_profile);
-                               SpeedProfileProperties &speed_profile);
     std::pair<std::size_t, std::size_t>
     BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,
-                                       std::vector<EdgeBasedNode> &node_based_edge_list,
+                           std::vector<EdgeBasedNode> &node_based_edge_list,
-                                       DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list);
+                           std::vector<bool> &node_is_startpoint,
-    void WriteNodeMapping(const std::vector<QueryNode> & internal_to_external_node_map);
+                           DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list);
-    void FindComponents(unsigned max_edge_id, const DeallocatingVector<EdgeBasedEdge>& edges, std::vector<EdgeBasedNode>& nodes) const;
+    void WriteNodeMapping(const std::vector<QueryNode> &internal_to_external_node_map);
-    void BuildRTree(const std::vector<EdgeBasedNode> &node_based_edge_list,
+    void FindComponents(unsigned max_edge_id,
+                        const DeallocatingVector<EdgeBasedEdge> &edges,
+                        std::vector<EdgeBasedNode> &nodes) const;
+    void BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list,
+                    std::vector<bool> node_is_startpoint,
                     const std::vector<QueryNode> &internal_to_external_node_map);
     std::shared_ptr<RestrictionMap> LoadRestrictionMap();
     std::shared_ptr<NodeBasedDynamicGraph>
     LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
                        std::unordered_set<NodeID> &traffic_lights,
-                       std::vector<QueryNode>& internal_to_external_node_map);
+                       std::vector<QueryNode> &internal_to_external_node_map);
 
-    void WriteEdgeBasedGraph(std::string const &output_file_filename, 
+    void WriteEdgeBasedGraph(std::string const &output_file_filename,
-                             size_t const max_edge_id, 
+                             size_t const max_edge_id,
-                             DeallocatingVector<EdgeBasedEdge> const & edge_based_edge_list);
+                             DeallocatingVector<EdgeBasedEdge> const &edge_based_edge_list);
 };
 #endif /* EXTRACTOR_HPP */

extractor/extractor_callbacks.cpp

@@ -193,7 +193,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                                 external_memory.all_edges_list.push_back(InternalExtractorEdge(
                                     OSMNodeID(first_node.ref()), OSMNodeID(last_node.ref()), name_id,
                                     backward_weight_data, true, false, parsed_way.roundabout,
-                                    parsed_way.is_access_restricted,
+                                    parsed_way.is_access_restricted, parsed_way.is_startpoint,
                                     parsed_way.backward_travel_mode, false));
                             });
 
@@ -214,7 +214,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                                 external_memory.all_edges_list.push_back(InternalExtractorEdge(
                                     OSMNodeID(first_node.ref()), OSMNodeID(last_node.ref()), name_id, forward_weight_data,
                                     true, !forward_only, parsed_way.roundabout,
-                                    parsed_way.is_access_restricted, parsed_way.forward_travel_mode,
+                                    parsed_way.is_access_restricted, parsed_way.is_startpoint, parsed_way.forward_travel_mode,
                                     split_edge));
                             });
         if (split_edge)
@@ -227,7 +227,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                     external_memory.all_edges_list.push_back(InternalExtractorEdge(
                         OSMNodeID(first_node.ref()), OSMNodeID(last_node.ref()), name_id, backward_weight_data, false,
                         true, parsed_way.roundabout, parsed_way.is_access_restricted,
-                        parsed_way.backward_travel_mode, true));
+                        parsed_way.is_startpoint, parsed_way.backward_travel_mode, true));
                 });
         }
 

extractor/internal_extractor_edge.hpp

@@ -63,7 +63,7 @@ struct InternalExtractorEdge
     };
 
     explicit InternalExtractorEdge()
-        : result(MIN_OSM_NODEID, MIN_OSM_NODEID, 0, 0, false, false, false, false,
+        : result(MIN_OSM_NODEID, MIN_OSM_NODEID, 0, 0, false, false, false, false, true,
                 TRAVEL_MODE_INACCESSIBLE, false)
     {
     }
@@ -76,6 +76,7 @@ struct InternalExtractorEdge
                                    bool backward,
                                    bool roundabout,
                                    bool access_restricted,
+                                   bool startpoint,
                                    TravelMode travel_mode,
                                    bool is_split)
         : result(OSMNodeID(source),
@@ -86,6 +87,7 @@ struct InternalExtractorEdge
                  backward,
                  roundabout,
                  access_restricted,
+                 startpoint,
                  travel_mode,
                  is_split),
           weight_data(std::move(weight_data))
@@ -104,12 +106,12 @@ struct InternalExtractorEdge
     static InternalExtractorEdge min_osm_value()
     {
         return InternalExtractorEdge(MIN_OSM_NODEID, MIN_OSM_NODEID, 0, WeightData(), false, false, false,
-                                     false, TRAVEL_MODE_INACCESSIBLE, false);
+                                     false, true, TRAVEL_MODE_INACCESSIBLE, false);
     }
     static InternalExtractorEdge max_osm_value()
     {
         return InternalExtractorEdge(MAX_OSM_NODEID, MAX_OSM_NODEID, 0, WeightData(), false,
-                                     false, false, false, TRAVEL_MODE_INACCESSIBLE, false);
+                                     false, false, false, true, TRAVEL_MODE_INACCESSIBLE, false);
     }
 
     static InternalExtractorEdge min_internal_value()

extractor/scripting_environment.cpp

@@ -117,6 +117,7 @@ void ScriptingEnvironment::init_lua_state(lua_State *lua_state)
             .def_readwrite("name", &ExtractionWay::name)
             .def_readwrite("roundabout", &ExtractionWay::roundabout)
             .def_readwrite("is_access_restricted", &ExtractionWay::is_access_restricted)
+            .def_readwrite("is_startpoint", &ExtractionWay::is_startpoint)
             .def_readwrite("duration", &ExtractionWay::duration)
             .property("forward_mode", &ExtractionWay::get_forward_mode,
                       &ExtractionWay::set_forward_mode)

unit_tests/algorithms/graph_compressor.cpp

@@ -28,14 +28,14 @@ BOOST_AUTO_TEST_CASE(long_road_test)
     using InputEdge = NodeBasedDynamicGraph::InputEdge;
     std::vector<InputEdge> edges = {
         // source, target, distance, edge_id, name_id, access_restricted, reversed, roundabout, travel_mode
-        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 0, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 0, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 2, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 2, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {2, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {2, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {2, 3, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {2, 3, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {3, 2, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {3, 2, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {3, 4, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {3, 4, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {4, 3, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT}
+        {4, 3, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT}
     };
 
     BOOST_ASSERT(edges[0].data.IsCompatibleTo(edges[2].data));
@@ -70,18 +70,18 @@ BOOST_AUTO_TEST_CASE(loop_test)
     using InputEdge = NodeBasedDynamicGraph::InputEdge;
     std::vector<InputEdge> edges = {
         // source, target, distance, edge_id, name_id, access_restricted, forward, backward, roundabout, travel_mode
-        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {0, 5, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {0, 5, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 0, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 0, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 2, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 2, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {2, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {2, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {2, 3, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {2, 3, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {3, 2, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {3, 2, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {3, 4, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {3, 4, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {4, 3, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {4, 3, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {4, 5, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {4, 5, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {5, 0, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {5, 0, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {5, 4, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {5, 4, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
     };
 
     BOOST_ASSERT(edges.size() == 12);
@@ -127,12 +127,12 @@ BOOST_AUTO_TEST_CASE(t_intersection)
     using InputEdge = NodeBasedDynamicGraph::InputEdge;
     std::vector<InputEdge> edges = {
         // source, target, distance, edge_id, name_id, access_restricted, reversed, roundabout, travel_mode
-        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 0, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 0, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 2, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 2, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 3, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 3, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {2, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {2, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {3, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {3, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
     };
 
     BOOST_ASSERT(edges[0].data.IsCompatibleTo(edges[1].data));
@@ -165,10 +165,10 @@ BOOST_AUTO_TEST_CASE(street_name_changes)
     using InputEdge = NodeBasedDynamicGraph::InputEdge;
     std::vector<InputEdge> edges = {
         // source, target, distance, edge_id, name_id, access_restricted, forward, backward, roundabout, travel_mode
-        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 0, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 0, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 2, 1, SPECIAL_EDGEID, 1, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 2, 1, SPECIAL_EDGEID, 1, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {2, 1, 1, SPECIAL_EDGEID, 1, false, false, false, TRAVEL_MODE_DEFAULT},
+        {2, 1, 1, SPECIAL_EDGEID, 1, false, false, false, true, TRAVEL_MODE_DEFAULT},
     };
 
     BOOST_ASSERT(edges[0].data.IsCompatibleTo(edges[1].data));
@@ -197,10 +197,10 @@ BOOST_AUTO_TEST_CASE(direction_changes)
     using InputEdge = NodeBasedDynamicGraph::InputEdge;
     std::vector<InputEdge> edges = {
         // source, target, distance, edge_id, name_id, access_restricted, reverse, roundabout, travel_mode
-        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {0, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {1, 0, 1, SPECIAL_EDGEID, 0, false, true,  false, TRAVEL_MODE_DEFAULT},
+        {1, 0, 1, SPECIAL_EDGEID, 0, false, true,  false, true, TRAVEL_MODE_DEFAULT},
-        {1, 2, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {1, 2, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
-        {2, 1, 1, SPECIAL_EDGEID, 0, false, false, false, TRAVEL_MODE_DEFAULT},
+        {2, 1, 1, SPECIAL_EDGEID, 0, false, false, false, true, TRAVEL_MODE_DEFAULT},
     };
 
     NodeBasedDynamicGraph graph(5, edges);