Remove logging.

include/engine/phantom_node.hpp

@@ -94,9 +94,6 @@ struct PhantomNode
         //         x              <-- this is PhantomNode.location
         // 0----1----2----3----4  <-- EdgeBasedGraph Node segments
         BOOST_ASSERT(forward_segment_id.enabled);
-        std::cout << "forward_distance: " << forward_distance;
-        std::cout << " forward_distance_offset: " << forward_distance_offset;
-        std::cout << std::endl;
         return forward_distance + forward_distance_offset;
     }
 
@@ -108,9 +105,6 @@ struct PhantomNode
         //         x              <-- this is PhantomNode.location
         // 0----1----2----3----4  <-- EdgeBasedGraph Node segments
         BOOST_ASSERT(reverse_segment_id.enabled);
-        std::cout << "reverse_distance: " << reverse_distance;
-        std::cout << " reverse_distance_offset: " << reverse_distance_offset;
-        std::cout << std::endl;
         return reverse_distance + reverse_distance_offset;
     }
 

include/partitioner/edge_based_graph_reader.hpp

@@ -40,16 +40,6 @@ splitBidirectionalEdges(const std::vector<extractor::EdgeBasedEdge> &edges)
         if (edge.data.weight == INVALID_EDGE_WEIGHT)
             continue;
 
-        std::cout << " EdgeBasedEdge {";
-        std::cout << " source " << edge.source << ", target: " << edge.target;
-        std::cout << " EdgeBasedEdgeData data {";
-        std::cout << " turn_id: " << edge.data.turn_id << ", weight: " << edge.data.weight;
-        std::cout << " distance: " << edge.data.distance << ", duration: " << edge.data.duration;
-        std::cout << " forward: " << (edge.data.forward == 0 ? "false" : "true")
-                  << ", backward: " << (edge.data.backward == 0 ? "false" : "true");
-        std::cout << " }";
-        std::cout << "}" << std::endl;
-
         directed.emplace_back(edge.source,
                               edge.target,
                               edge.data.turn_id,
@@ -69,21 +59,6 @@ splitBidirectionalEdges(const std::vector<extractor::EdgeBasedEdge> &edges)
                               edge.data.forward);
     }
 
-    std::cout << "Directed edges" << std::endl;
-    for (const auto &edge : directed)
-    {
-        std::cout << " EdgeBasedEdge {";
-        std::cout << " source " << edge.source << ", target: " << edge.target;
-        std::cout << " EdgeBasedEdgeData data {";
-        std::cout << " turn_id: " << edge.data.turn_id << ", weight: " << edge.data.weight;
-        std::cout << " distance: " << edge.data.distance << ", duration: " << edge.data.duration;
-        std::cout << " forward: " << (edge.data.forward == 0 ? "false" : "true")
-                  << ", backward: " << (edge.data.backward == 0 ? "false" : "true");
-        std::cout << " }";
-        std::cout << "}" << std::endl;
-    }
-    std::cout << "Done directed edges" << std::endl;
-
     return directed;
 }
 
@@ -98,21 +73,6 @@ std::vector<OutputEdgeT> prepareEdgesForUsageInGraph(std::vector<extractor::Edge
                std::tie(rhs.source, rhs.target, lhs.data.forward, rhs.data.weight);
     });
 
-    std::cout << "Directed edges after sorting" << std::endl;
-    for (const auto &edge : edges)
-    {
-        std::cout << " EdgeBasedEdge {";
-        std::cout << " source " << edge.source << ", target: " << edge.target;
-        std::cout << " EdgeBasedEdgeData data {";
-        std::cout << " turn_id: " << edge.data.turn_id << ", weight: " << edge.data.weight;
-        std::cout << " distance: " << edge.data.distance << ", duration: " << edge.data.duration;
-        std::cout << " forward: " << (edge.data.forward == 0 ? "false" : "true")
-                  << ", backward: " << (edge.data.backward == 0 ? "false" : "true");
-        std::cout << " }";
-        std::cout << "}" << std::endl;
-    }
-    std::cout << "Done sorted directed edges" << std::endl;
-
     std::vector<OutputEdgeT> output_edges;
     output_edges.reserve(edges.size());
 
@@ -134,18 +94,6 @@ std::vector<OutputEdgeT> prepareEdgesForUsageInGraph(std::vector<extractor::Edge
             continue;
         }
 
-        std::cout << " EdgeBasedEdge2 {";
-        std::cout << " source " << begin_interval->source << ", target: " << begin_interval->target;
-        std::cout << " EdgeBasedEdgeData data {";
-        std::cout << " turn_id: " << begin_interval->data.turn_id
-                  << ", weight: " << begin_interval->data.weight;
-        std::cout << " distance: " << begin_interval->data.distance
-                  << ", duration: " << begin_interval->data.duration;
-        std::cout << " forward: " << (begin_interval->data.forward == 0 ? "false" : "true")
-                  << ", backward: " << (begin_interval->data.backward == 0 ? "false" : "true");
-        std::cout << " }";
-        std::cout << "}" << std::endl;
-
         BOOST_ASSERT_MSG(begin_interval->data.forward != begin_interval->data.backward,
                          "The forward and backward flag need to be mutally exclusive");
 

src/contractor/contractor.cpp

@@ -103,20 +103,6 @@ int Contractor::Run()
     std::vector<std::vector<bool>> edge_filters;
     std::vector<std::vector<bool>> cores;
 
-    std::cout << "Pre contractor edge-based-graph" << std::endl;
-    for (const auto &edge : edge_based_edge_list)
-    {
-        std::cout << " EdgeBasedEdge {";
-        std::cout << " source " << edge.source << ", target: " << edge.target;
-        std::cout << " EdgeBasedEdgeData data {";
-        std::cout << " turn_id: " << edge.data.turn_id << ", weight: " << edge.data.weight;
-        std::cout << " distance: " << edge.data.distance << ", duration: " << edge.data.duration;
-        std::cout << " forward: " << (edge.data.forward == 0 ? "false" : "true")
-                  << ", backward: " << (edge.data.backward == 0 ? "false" : "true");
-        std::cout << " }";
-        std::cout << "}" << std::endl;
-    }
-
     std::tie(query_graph, edge_filters) = contractExcludableGraph(
         toContractorGraph(number_of_edge_based_nodes, std::move(edge_based_edge_list)),
         std::move(node_weights),

src/contractor/graph_contractor.cpp

@@ -207,8 +207,6 @@ void ContractNode(ContractorThreadData *data,
                     }
                     else
                     {
-                        std::cout << "Contractor: " << in_data.distance << "," << out_data.distance
-                                  << std::endl;
                         // CAREFUL: This only works due to the independent node-setting. This
                         // guarantees that source is not connected to another node that is
                         // contracted
@@ -280,8 +278,6 @@ void ContractNode(ContractorThreadData *data,
                 }
                 else
                 {
-                    std::cout << "Contractor: " << in_data.distance << "," << out_data.distance
-                              << std::endl;
                     inserted_edges.emplace_back(source,
                                                 target,
                                                 path_weight,

src/engine/routing_algorithms/many_to_many_ch.cpp

@@ -68,7 +68,6 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
 
             const auto edge_duration = data.duration;
             const auto edge_distance = data.distance;
-            std::cout << "edge_distance " << data.distance << std::endl;
 
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
             const auto to_weight = weight + edge_weight;

src/extractor/edge_based_graph_factory.cpp

@@ -653,8 +653,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             auto duration = boost::numeric_cast<EdgeWeight>(edge_data1.duration + duration_penalty);
             auto distance = boost::numeric_cast<EdgeDistance>(edge_data1.distance);
 
-            std::cout << "EBGF distance: " << distance << std::endl;
-
             EdgeBasedEdge edge_based_edge = {edge_based_node_from,
                                              edge_based_node_to,
                                              SPECIAL_NODEID, // This will be updated once the main