Add protobuf descriptor

Algorithms/PolylineCompressor.cpp

@@ -69,11 +69,10 @@ void PolylineCompressor::encodeNumber(int number_to_encode, std::string &output)
  }
 }
 
-JSON::String PolylineCompressor::printEncodedString(const std::vector<SegmentInformation> &polyline)
- const
+std::string PolylineCompressor::printEncodedStr(const std::vector<SegmentInformation> &polyline) const
 {
- std::string output;
  std::vector<int> delta_numbers;
+ std::string output;
  if (!polyline.empty())
  {
  FixedPointCoordinate last_coordinate = {0, 0};
@@ -90,25 +89,40 @@ JSON::String PolylineCompressor::printEncodedString(const std::vector<SegmentInf
  }
  encodeVectorSignedNumber(delta_numbers, output);
  }
+ return output;
+}
+
+JSON::String PolylineCompressor::printEncodedString(const std::vector<SegmentInformation> &polyline) const
+{
+ std::string output = printEncodedStr(polyline);
  JSON::String return_value(output);
  return return_value;
 }
 
-JSON::Array
-PolylineCompressor::printUnencodedString(const std::vector<SegmentInformation> &polyline) const
+std::vector<std::string> PolylineCompressor::printUnencodedStr(const std::vector<SegmentInformation> &polyline) const
 {
- JSON::Array json_geometry_array;
+ std::vector<std::string> output;
  for (const auto &segment : polyline)
  {
  if (segment.necessary)
  {
- std::string tmp, output;
+ std::string tmp, res;
  FixedPointCoordinate::convertInternalLatLonToString(segment.location.lat, tmp);
- output += (tmp + ",");
+ res += (tmp + ",");
  FixedPointCoordinate::convertInternalLatLonToString(segment.location.lon, tmp);
- output += tmp;
- json_geometry_array.values.push_back(output);
+ res += tmp;
+ output.push_back(res);
  }
  }
+ return output;
+}
+
+JSON::Array
+PolylineCompressor::printUnencodedString(const std::vector<SegmentInformation> &polyline) const
+{
+ JSON::Array json_geometry_array;
+ std::vector<std::string> output = printUnencodedStr(polyline);
+ for (std::string str : output)
+ json_geometry_array.values.push_back(str);
  return json_geometry_array;
 }

Algorithms/PolylineCompressor.h

@@ -43,6 +43,10 @@ class PolylineCompressor
  void encodeNumber(int number_to_encode, std::string &output) const;
 
  public:
+ std::string printEncodedStr(const std::vector<SegmentInformation> &polyline) const;
+
+ std::vector<std::string> printUnencodedStr(const std::vector<SegmentInformation> &polyline) const;
+
  JSON::String printEncodedString(const std::vector<SegmentInformation> &polyline) const;
 
  JSON::Array printUnencodedString(const std::vector<SegmentInformation> &polyline) const;

CMakeLists.txt

@@ -11,6 +11,13 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 include(CheckCXXCompilerFlag)
 include(FindPackageHandleStandardArgs)
 
+
+find_package(Protobuf REQUIRED)
+include_directories(${PROTOBUF_INCLUDE_DIRS})
+file(GLOB ProtoFiles "${CMAKE_CURRENT_SOURCE_DIR}/Descriptors/*.proto")
+PROTOBUF_GENERATE_CPP(ProtoSources ProtoHeaders ${ProtoFiles})
+add_library(messages STATIC ${ProtoSources} ${ProtoHeaders})
+
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 include(GetGitRevisionDescription)
 git_describe(GIT_DESCRIPTION)
@@ -52,7 +59,9 @@ configure_file(
 )
 file(GLOB ExtractorGlob Extractor/*.cpp)
 file(GLOB ImporterGlob DataStructures/Import*.cpp)
-add_library(IMPORT STATIC ${ImporterGlob})
+
+include_directories(${CMAKE_BINARY_DIR})
+add_library(IMPORT STATIC ${ImporterGlob} ${ProtoHeaders})
 set(ExtractorSources extractor.cpp ${ExtractorGlob})
 add_executable(osrm-extract ${ExtractorSources})
 
@@ -200,7 +209,7 @@ include_directories(${Boost_INCLUDE_DIRS})
 target_link_libraries(OSRM ${Boost_LIBRARIES} COORDLIB)
 target_link_libraries(osrm-extract ${Boost_LIBRARIES} FINGERPRINT GITDESCRIPTION COORDLIB IMPORT)
 target_link_libraries(osrm-prepare ${Boost_LIBRARIES} FINGERPRINT GITDESCRIPTION COORDLIB IMPORT)
-target_link_libraries(osrm-routed ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM FINGERPRINT GITDESCRIPTION)
+target_link_libraries(osrm-routed ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM FINGERPRINT GITDESCRIPTION messages)
 target_link_libraries(osrm-datastore ${Boost_LIBRARIES} FINGERPRINT GITDESCRIPTION COORDLIB)
 target_link_libraries(datastructure-tests ${Boost_LIBRARIES} COORDLIB)
 target_link_libraries(rtree-bench ${Boost_LIBRARIES} COORDLIB)
@@ -270,6 +279,9 @@ find_package(Protobuf REQUIRED)
 include_directories(${PROTOBUF_INCLUDE_DIRS})
 target_link_libraries(osrm-extract ${PROTOBUF_LIBRARY})
 target_link_libraries(osrm-prepare ${PROTOBUF_LIBRARY})
+target_link_libraries(osrm-routed ${PROTOBUF_LIBRARY})
+
+
 
 find_package(BZip2 REQUIRED)
 include_directories(${BZIP_INCLUDE_DIRS})

Descriptors/BaseDescriptor.h

@@ -28,12 +28,23 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef BASE_DESCRIPTOR_H
 #define BASE_DESCRIPTOR_H
 
+#include "../typedefs.h"
+
+#include "DescriptionFactory.h"
+#include "../Algorithms/ObjectToBase64.h"
+#include "../Algorithms/ExtractRouteNames.h"
+#include "../DataStructures/Range.h"
+#include "../DataStructures/SegmentInformation.h"
+#include "../DataStructures/TurnInstructions.h"
 #include "../DataStructures/PhantomNodes.h"
 #include "../DataStructures/RawRouteData.h"
-#include "../typedefs.h"
+#include "../Util/Azimuth.h"
+#include "../Util/StringUtil.h"
+#include "../Util/TimingUtil.h"
 
 #include <osrm/Reply.h>
 
+#include <algorithm>
 #include <string>
 #include <vector>
 
@@ -50,12 +61,164 @@ struct DescriptorConfig
 
 template <class DataFacadeT> class BaseDescriptor
 {
- public:
- BaseDescriptor() {}
- // Maybe someone can explain the pure virtual destructor thing to me (dennis)
+public:
+ DataFacadeT *facade;
+ DescriptorConfig config;
+ DescriptionFactory description_factory, alternate_description_factory;
+ FixedPointCoordinate current;
+ unsigned entered_restricted_area_count;
+ struct RoundAbout
+ {
+ RoundAbout() : start_index(INT_MAX), name_id(INVALID_NAMEID), leave_at_exit(INT_MAX) {}
+ int start_index;
+ unsigned name_id;
+ int leave_at_exit;
+ } round_about;
+
+ struct Segment
+ {
+ Segment() : name_id(INVALID_NAMEID), length(-1), position(0) {}
+ Segment(unsigned n, int l, unsigned p) : name_id(n), length(l), position(p) {}
+ unsigned name_id;
+ int length;
+ unsigned position;
+ };
+ std::vector<Segment> shortest_path_segments, alternative_path_segments;
+ ExtractRouteNames<DataFacadeT, Segment> GenerateRouteNames;
+
+ BaseDescriptor(DataFacadeT *facade) : facade(facade), entered_restricted_area_count(0) {}
+
+ void SetConfig(const DescriptorConfig &c) { config = c; }
+
+ unsigned DescribeLeg(const std::vector<PathData> &route_leg,
+ const PhantomNodes &leg_phantoms,
+ const bool target_traversed_in_reverse,
+ const bool is_via_leg)
+ {
+ unsigned added_element_count = 0;
+ // Get all the coordinates for the computed route
+ FixedPointCoordinate current_coordinate;
+ for (const PathData &path_data : route_leg)
+ {
+ current_coordinate = facade->GetCoordinateOfNode(path_data.node);
+ description_factory.AppendSegment(current_coordinate, path_data);
+ ++added_element_count;
+ }
+ description_factory.SetEndSegment(leg_phantoms.target_phantom, target_traversed_in_reverse, is_via_leg);
+ ++added_element_count;
+ BOOST_ASSERT((route_leg.size() + 1) == added_element_count);
+ return added_element_count;
+ }
+
+ struct Instruction
+ {
+ Instruction() : instructionId(""), streetName(""), length(0),
+ position(0), time(0), lengthStr(""), earthDirection(""), azimuth(0),
+ travelMode(0)
+ {}
+ Instruction(const std::string &i, const std::string &s, const int l,
+ const int p, const int t, const std::string &ls, const std::string &e,
+ const int a, TravelMode const tm) : instructionId(i), streetName(s), length(l),
+ position(p), time(t), lengthStr(ls), earthDirection(e), azimuth(a), travelMode(tm)
+ {}
+ std::string instructionId;
+ std::string streetName;
+ int length;
+ int position;
+ int time;
+ std::string lengthStr;
+ std::string earthDirection;
+ int azimuth;
+ TravelMode travelMode;
+ };
+
+
+
+ inline void BuildTextualDescription(DescriptionFactory &description_factory,
+ std::vector<Instruction> &instructions,
+ const int route_length,
+ std::vector<Segment> &route_segments_list)
+ {
+ // Segment information has following format:
+ //["instruction id","streetname",length,position,time,"length","earth_direction",azimuth]
+ unsigned necessary_segments_running_index = 0;
+ round_about.leave_at_exit = 0;
+ round_about.name_id = 0;
+ std::string temp_dist, temp_length, temp_duration, temp_bearing, temp_instruction;
+
+ // Fetch data from Factory and generate a string from it.
+ Instruction instruction;
+
+ for (const SegmentInformation &segment : description_factory.path_description)
+ {
+ TurnInstruction current_instruction = segment.turn_instruction;
+ entered_restricted_area_count += (current_instruction != segment.turn_instruction);
+ if (TurnInstructionsClass::TurnIsNecessary(current_instruction))
+ {
+ if (TurnInstruction::EnterRoundAbout == current_instruction)
+ {
+ round_about.name_id = segment.name_id;
+ round_about.start_index = necessary_segments_running_index;
+ }
+ else
+ {
+ std::string current_turn_instruction;
+ if (TurnInstruction::LeaveRoundAbout == current_instruction)
+ {
+ temp_instruction =
+ IntToString(as_integer(TurnInstruction::EnterRoundAbout));
+ current_turn_instruction += temp_instruction;
+ current_turn_instruction += "-";
+ temp_instruction = IntToString(round_about.leave_at_exit + 1);
+ current_turn_instruction += temp_instruction;
+ round_about.leave_at_exit = 0;
+ }
+ else
+ {
+ temp_instruction = IntToString(as_integer(current_instruction));
+ current_turn_instruction += temp_instruction;
+ }
+
+ instruction.instructionId = current_turn_instruction;
+ instruction.streetName = facade->GetEscapedNameForNameID(segment.name_id);
+ instruction.length = std::round(segment.length);
+ instruction.position = necessary_segments_running_index;
+ instruction.time = round(segment.duration / 10);
+ instruction.lengthStr = UintToString(static_cast<int>(segment.length)) + "m";
+ const double bearing_value = (segment.bearing / 10.);
+ instruction.earthDirection = Azimuth::Get(bearing_value);
+ instruction.azimuth = static_cast<unsigned>(round(bearing_value));
+ instruction.travelMode = segment.travel_mode;
+
+ route_segments_list.emplace_back(
+ segment.name_id, static_cast<int>(segment.length), static_cast<unsigned>(route_segments_list.size()));
+ instructions.push_back(instruction);
+ }
+ }
+ else if (TurnInstruction::StayOnRoundAbout == current_instruction)
+ {
+ ++round_about.leave_at_exit;
+ }
+ if (segment.necessary)
+ {
+ ++necessary_segments_running_index;
+ }
+ }
+
+ temp_instruction = IntToString(as_integer(TurnInstruction::ReachedYourDestination));
+ instruction.instructionId = temp_instruction;
+ instruction.streetName = "";
+ instruction.length = 0;
+ instruction.position = necessary_segments_running_index - 1;
+ instruction.time = 0;
+ instruction.lengthStr = "0m";
+ instruction.earthDirection = Azimuth::Get(0.0);
+ instruction.azimuth = 0.;
+ instructions.push_back(instruction);
+ }
+
  virtual ~BaseDescriptor() {}
  virtual void Run(const RawRouteData &raw_route, http::Reply &reply) = 0;
- virtual void SetConfig(const DescriptorConfig &config) = 0;
 };
 
 #endif // BASE_DESCRIPTOR_H

Descriptors/DescriptionFactory.cpp

@@ -109,6 +109,17 @@ void DescriptionFactory::AppendSegment(const FixedPointCoordinate &coordinate,
  path_point.travel_mode);
 }
 
+std::string DescriptionFactory::AppendEncodedPolylineStringEncoded()
+{
+ return polyline_compressor.printEncodedStr(path_description);
+}
+
+std::vector<std::string> DescriptionFactory::AppendEncodedPolylineStringUnencoded()
+{
+ return polyline_compressor.printUnencodedStr(path_description);
+}
+
+
 JSON::Value DescriptionFactory::AppendEncodedPolylineString(const bool return_encoded)
 {
  if (return_encoded)

Descriptors/DescriptionFactory.h

@@ -81,6 +81,8 @@ class DescriptionFactory
  void BuildRouteSummary(const double distance, const unsigned time);
  void SetStartSegment(const PhantomNode &start_phantom, const bool traversed_in_reverse);
  void SetEndSegment(const PhantomNode &start_phantom, const bool traversed_in_reverse, const bool is_via_location = false);
+ std::string AppendEncodedPolylineStringEncoded();
+ std::vector<std::string> AppendEncodedPolylineStringUnencoded();
  JSON::Value AppendEncodedPolylineString(const bool return_encoded);
  std::vector<unsigned> const & GetViaIndices() const;
 

Descriptors/GPXDescriptor.h

@@ -57,9 +57,9 @@ template <class DataFacadeT> class GPXDescriptor : public BaseDescriptor<DataFac
  }
 
  public:
- GPXDescriptor(DataFacadeT *facade) : facade(facade) {}
+ GPXDescriptor(DataFacadeT *facade) : BaseDescriptor<DataFacadeT>(facade) {}
 
- void SetConfig(const DescriptorConfig &c) final { config = c; }
+ void SetConfig(const DescriptorConfig &c) { config = c; }
 
  // TODO: reorder parameters
  void Run(const RawRouteData &raw_route, http::Reply &reply) final