Distance Tables and new JSON generator

Algorithms/BFSComponentExplorer.h

@@ -94,7 +94,7 @@ template <typename GraphT> class BFSComponentExplorer
                 const NodeID to_node_of_only_restriction =
                     m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v);
 
-                for (auto e2 = m_graph.BeginEdges(v); e2 < m_graph.EndEdges(v); ++e2)
+                for (auto e2 : m_graph.GetAdjacentEdgeRange(v))
                 {
                     const NodeID w = m_graph.GetTarget(e2);
 

Algorithms/DouglasPeucker.cpp

@@ -29,6 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "DouglasPeucker.h"
 #include "../DataStructures/SegmentInformation.h"
+#include "../Util/SimpleLogger.h"
 
 #include <boost/assert.hpp>
 
@@ -62,19 +63,28 @@ DouglasPeucker::DouglasPeucker()
 
 void DouglasPeucker::Run(std::vector<SegmentInformation> &input_geometry, const unsigned zoom_level)
 {
+    input_geometry.front().necessary = true;
+    input_geometry.back().necessary = true;
+
     BOOST_ASSERT_MSG(!input_geometry.empty(), "geometry invalid");
-    if (input_geometry.size() <= 2)
+    if (input_geometry.size() < 2)
     {
         return;
     }
 
+    SimpleLogger().Write() << "input_geometry.size()=" << input_geometry.size();
+
     {
         BOOST_ASSERT_MSG(zoom_level < 19, "unsupported zoom level");
         unsigned left_border = 0;
         unsigned right_border = 1;
         // Sweep over array and identify those ranges that need to be checked
         do
         {
+            if (!input_geometry[left_border].necessary)
+            {
+              SimpleLogger().Write() << "broken interval [" << left_border << "," << right_border << "]";
+            }
             BOOST_ASSERT_MSG(input_geometry[left_border].necessary,
                              "left border must be necessary");
             BOOST_ASSERT_MSG(input_geometry.back().necessary, "right border must be necessary");

Algorithms/ExtractRouteNames.h

@@ -0,0 +1,142 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef EXTRACT_ROUTE_NAMES_H
+#define EXTRACT_ROUTE_NAMES_H
+
+#include <boost/assert.hpp>
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+struct RouteNames
+{
+    std::string shortest_path_name_1;
+    std::string shortest_path_name_2;
+    std::string alternative_path_name_1;
+    std::string alternative_path_name_2;
+};
+
+// construct routes names
+template <class DataFacadeT, class SegmentT> struct ExtractRouteNames
+{
+    RouteNames operator()(std::vector<SegmentT> &shortest_path_segments,
+                          std::vector<SegmentT> &alternative_path_segments,
+                          const DataFacadeT *facade)
+    {
+        RouteNames route_names;
+
+        SegmentT shortest_segment_1, shortest_segment_2;
+        SegmentT alternative_segment_1, alternative_segment_2;
+
+        auto length_comperator = [](SegmentT a, SegmentT b)
+        { return a.length > b.length; };
+        auto name_id_comperator = [](SegmentT a, SegmentT b)
+        { return a.name_id < b.name_id; };
+
+        if (shortest_path_segments.empty())
+        {
+            return route_names;
+        }
+
+        std::sort(shortest_path_segments.begin(), shortest_path_segments.end(), length_comperator);
+        shortest_segment_1 = shortest_path_segments[0];
+        if (!alternative_path_segments.empty())
+        {
+            std::sort(alternative_path_segments.begin(),
+                      alternative_path_segments.end(),
+                      length_comperator);
+            alternative_segment_1 = alternative_path_segments[0];
+        }
+        std::vector<SegmentT> shortest_path_set_difference(shortest_path_segments.size());
+        std::vector<SegmentT> alternative_path_set_difference(alternative_path_segments.size());
+        std::set_difference(shortest_path_segments.begin(),
+                            shortest_path_segments.end(),
+                            alternative_path_segments.begin(),
+                            alternative_path_segments.end(),
+                            shortest_path_set_difference.begin(),
+                            name_id_comperator);
+        int size_of_difference = shortest_path_set_difference.size();
+        if (size_of_difference)
+        {
+            int i = 0;
+            while (i < size_of_difference &&
+                   shortest_path_set_difference[i].name_id == shortest_path_segments[0].name_id)
+            {
+                ++i;
+            }
+            if (i < size_of_difference)
+            {
+                shortest_segment_2 = shortest_path_set_difference[i];
+            }
+        }
+
+        std::set_difference(alternative_path_segments.begin(),
+                            alternative_path_segments.end(),
+                            shortest_path_segments.begin(),
+                            shortest_path_segments.end(),
+                            alternative_path_set_difference.begin(),
+                            name_id_comperator);
+        size_of_difference = alternative_path_set_difference.size();
+        if (size_of_difference)
+        {
+            int i = 0;
+            while (i < size_of_difference &&
+                   alternative_path_set_difference[i].name_id ==
+                       alternative_path_segments[0].name_id)
+            {
+                ++i;
+            }
+            if (i < size_of_difference)
+            {
+                alternative_segment_2 = alternative_path_set_difference[i];
+            }
+        }
+        if (shortest_segment_1.position > shortest_segment_2.position)
+        {
+            std::swap(shortest_segment_1, shortest_segment_2);
+        }
+        if (alternative_segment_1.position > alternative_segment_2.position)
+        {
+            std::swap(alternative_segment_1, alternative_segment_2);
+        }
+        route_names.shortest_path_name_1 =
+            facade->GetEscapedNameForNameID(shortest_segment_1.name_id);
+        route_names.shortest_path_name_2 =
+            facade->GetEscapedNameForNameID(shortest_segment_2.name_id);
+
+        route_names.alternative_path_name_1 =
+            facade->GetEscapedNameForNameID(alternative_segment_1.name_id);
+        route_names.alternative_path_name_2 =
+            facade->GetEscapedNameForNameID(alternative_segment_2.name_id);
+
+        return route_names;
+    }
+};
+
+#endif // EXTRACT_ROUTE_NAMES_H

Algorithms/PolylineCompressor.cpp

@@ -26,6 +26,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "PolylineCompressor.h"
+#include "../Util/StringUtil.h"
+
+//TODO: return vector of start indices for each leg
 
 void PolylineCompressor::encodeVectorSignedNumber(std::vector<int> &numbers, std::string &output)
     const
@@ -39,9 +42,9 @@ void PolylineCompressor::encodeVectorSignedNumber(std::vector<int> &numbers, std
             numbers[i] = ~(numbers[i]);
         }
     }
-    for (unsigned i = 0; i < end; ++i)
+    for (const int number: numbers)
     {
-        encodeNumber(numbers[i], output);
+        encodeNumber(number, output);
     }
 }
 
@@ -66,37 +69,36 @@ void PolylineCompressor::encodeNumber(int number_to_encode, std::string &output)
     }
 }
 
-void PolylineCompressor::printEncodedString(const std::vector<SegmentInformation> &polyline,
-                                            std::string &output) const
+JSON::String PolylineCompressor::printEncodedString(const std::vector<SegmentInformation> &polyline) const
 {
+    std::string output;
     std::vector<int> delta_numbers;
-    output += "\"";
     if (!polyline.empty())
     {
         FixedPointCoordinate last_coordinate = polyline[0].location;
         delta_numbers.emplace_back(last_coordinate.lat);
         delta_numbers.emplace_back(last_coordinate.lon);
-        for (unsigned i = 1; i < polyline.size(); ++i)
+        for (const auto & segment : polyline)
         {
-            if (polyline[i].necessary)
+            if (segment.necessary)
             {
-                int lat_diff = polyline[i].location.lat - last_coordinate.lat;
-                int lon_diff = polyline[i].location.lon - last_coordinate.lon;
+                int lat_diff = segment.location.lat - last_coordinate.lat;
+                int lon_diff = segment.location.lon - last_coordinate.lon;
                 delta_numbers.emplace_back(lat_diff);
                 delta_numbers.emplace_back(lon_diff);
-                last_coordinate = polyline[i].location;
+                last_coordinate = segment.location;
             }
         }
         encodeVectorSignedNumber(delta_numbers, output);
     }
-    output += "\"";
+    JSON::String return_value(output);
+    return return_value;
 }
 
-void PolylineCompressor::printEncodedString(const std::vector<FixedPointCoordinate> &polyline,
-                                            std::string &output) const
+JSON::String PolylineCompressor::printEncodedString(const std::vector<FixedPointCoordinate> &polyline) const
 {
+    std::string output;
     std::vector<int> delta_numbers(2 * polyline.size());
-    output += "\"";
     if (!polyline.empty())
     {
         delta_numbers[0] = polyline[0].lat;
@@ -110,53 +112,40 @@ void PolylineCompressor::printEncodedString(const std::vector<FixedPointCoordina
         }
         encodeVectorSignedNumber(delta_numbers, output);
     }
-    output += "\"";
+    JSON::String return_value(output);
+    return return_value;
 }
 
-void PolylineCompressor::printUnencodedString(const std::vector<FixedPointCoordinate> &polyline,
-                                              std::string &output) const
+
+JSON::Array PolylineCompressor::printUnencodedString(const std::vector<FixedPointCoordinate> &polyline) const
 {
-    output += "[";
-    std::string tmp;
-    for (unsigned i = 0; i < polyline.size(); i++)
+    JSON::Array json_geometry_array;
+    for( const auto & coordinate : polyline)
     {
-        FixedPointCoordinate::convertInternalLatLonToString(polyline[i].lat, tmp);
-        output += "[";
-        output += tmp;
-        FixedPointCoordinate::convertInternalLatLonToString(polyline[i].lon, tmp);
-        output += ", ";
+        std::string tmp, output;
+        FixedPointCoordinate::convertInternalLatLonToString(coordinate.lat, tmp);
+        output += (tmp + ",");
+        FixedPointCoordinate::convertInternalLatLonToString(coordinate.lon, tmp);
         output += tmp;
-        output += "]";
-        if (i < polyline.size() - 1)
-        {
-            output += ",";
-        }
+        json_geometry_array.values.push_back(output);
     }
-    output += "]";
+    return json_geometry_array;
 }
 
-void PolylineCompressor::printUnencodedString(const std::vector<SegmentInformation> &polyline,
-                                              std::string &output) const
+JSON::Array PolylineCompressor::printUnencodedString(const std::vector<SegmentInformation> &polyline) const
 {
-    output += "[";
-    std::string tmp;
-    for (unsigned i = 0; i < polyline.size(); i++)
+    JSON::Array json_geometry_array;
+    for( const auto & segment : polyline)
     {
-        if (!polyline[i].necessary)
-        {
-            continue;
-        }
-        FixedPointCoordinate::convertInternalLatLonToString(polyline[i].location.lat, tmp);
-        output += "[";
-        output += tmp;
-        FixedPointCoordinate::convertInternalLatLonToString(polyline[i].location.lon, tmp);
-        output += ", ";
-        output += tmp;
-        output += "]";
-        if (i < polyline.size() - 1)
+        if (segment.necessary)
         {
-            output += ",";
+            std::string tmp, output;
+            FixedPointCoordinate::convertInternalLatLonToString(segment.location.lat, tmp);
+            output += (tmp + ",");
+            FixedPointCoordinate::convertInternalLatLonToString(segment.location.lon, tmp);
+            output += tmp;
+            json_geometry_array.values.push_back(output);
         }
     }
-    output += "]";
+    return json_geometry_array;
 }

Algorithms/PolylineCompressor.h

@@ -28,8 +28,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef POLYLINECOMPRESSOR_H_
 #define POLYLINECOMPRESSOR_H_
 
+#include "../DataStructures/JSONContainer.h"
 #include "../DataStructures/SegmentInformation.h"
-#include "../Util/StringUtil.h"
 
 #include <string>
 #include <vector>
@@ -42,17 +42,13 @@ class PolylineCompressor
     void encodeNumber(int number_to_encode, std::string &output) const;
 
   public:
-    void printEncodedString(const std::vector<SegmentInformation> &polyline,
-                            std::string &output) const;
+    JSON::String printEncodedString(const std::vector<SegmentInformation> &polyline) const;
 
-    void printEncodedString(const std::vector<FixedPointCoordinate> &polyline,
-                            std::string &output) const;
+    JSON::String printEncodedString(const std::vector<FixedPointCoordinate> &polyline) const;
 
-    void printUnencodedString(const std::vector<FixedPointCoordinate> &polyline,
-                              std::string &output) const;
+    JSON::Array printUnencodedString(const std::vector<FixedPointCoordinate> &polyline) const;
 
-    void printUnencodedString(const std::vector<SegmentInformation> &polyline,
-                              std::string &output) const;
+    JSON::Array printUnencodedString(const std::vector<SegmentInformation> &polyline) const;
 };
 
 #endif /* POLYLINECOMPRESSOR_H_ */