Merge pull request #20 from opentraffic/max_length

Update OSMLR segment definitions to not exceed kMaximumLength (1km for now).

Author: dnesbitt61

include/osmlr/output/geojson.hpp

@@ -13,6 +13,11 @@ struct geojson : public output {
   virtual ~geojson();
 
   void add_path(const valhalla::baldr::merge::path &);
+  void output_segment(const valhalla::baldr::merge::path &p);
+  void output_segment(const std::vector<valhalla::midgard::PointLL>& shape,
+                      const valhalla::baldr::DirectedEdge* edge,
+                      const valhalla::baldr::GraphId& edgeid);
+  void split_path(const valhalla::baldr::merge::path& p, const uint32_t total_length);
   void finish();
 
 private:

include/osmlr/output/tiles.hpp

@@ -7,17 +7,67 @@
 namespace osmlr {
 namespace output {
 
+enum class FormOfWay {
+  kUndefined = 0,
+  kMotorway = 1,
+  kMultipleCarriageway = 2,
+  kSingleCarriageway = 3,
+  kRoundabout = 4,
+  kTrafficSquare = 5,
+  kSlipRoad = 6,
+  kOther = 7
+};
+
+struct lrp {
+  bool at_node;
+  const valhalla::midgard::PointLL coord;
+  const uint16_t bear;
+  const valhalla::baldr::RoadClass start_frc;
+  const FormOfWay start_fow;
+  const valhalla::baldr::RoadClass least_frc;
+  const uint32_t length;
+
+  lrp(const bool at_node_,
+      const valhalla::midgard::PointLL &coord_,
+      uint16_t bear_,
+      valhalla::baldr::RoadClass start_frc_,
+      FormOfWay start_fow_,
+      valhalla::baldr::RoadClass least_frc_,
+      uint32_t length_)
+    : at_node(at_node_)
+    , coord(coord_)
+    , bear(bear_)
+    , start_frc(start_frc_)
+    , start_fow(start_fow_)
+    , least_frc(least_frc_)
+    , length(length_)
+    {}
+};
+
 struct tiles : public output {
   tiles(valhalla::baldr::GraphReader &reader, std::string base_dir, size_t max_fds, uint32_t max_length = 15000);
   virtual ~tiles();
 
-  void add_path(const valhalla::baldr::merge::path &);
+  void add_path(const valhalla::baldr::merge::path &p);
+  void split_path(const valhalla::baldr::merge::path &p, const uint32_t total_length);
+  void output_segment(const valhalla::baldr::merge::path &p);
+  void output_segment(const std::vector<valhalla::midgard::PointLL>& shape,
+                      const valhalla::baldr::DirectedEdge* edge,
+                      const valhalla::baldr::GraphId& edgeid,
+                      const bool start_at_node, const bool end_at_node);
+  void output_segment(std::vector<lrp>& lrps, const valhalla::baldr::GraphId& tile_id);
   void finish();
 
 private:
   valhalla::baldr::GraphReader &m_reader;
   util::tile_writer m_writer;
   uint32_t m_max_length;
+
+  std::vector<lrp> build_segment_descriptor(const valhalla::baldr::merge::path &p);
+  std::vector<lrp> build_segment_descriptor(const std::vector<valhalla::midgard::PointLL>& shape,
+                                            const valhalla::baldr::DirectedEdge* edge,
+                                            const bool start_at_node,
+                                            const bool end_at_node);
 };
 
 } // namespace output

proto

@@ -1,10 +1,18 @@
 #include "osmlr/output/geojson.hpp"
+#include <valhalla/midgard/util.h>
 #include <stdexcept>
 
+namespace vm = valhalla::midgard;
 namespace vb = valhalla::baldr;
 
 namespace {
 
+// Minimum length for an OSMLR segment
+constexpr uint32_t kMinimumLength = 5;
+
+// Maximum length for an OSMLR segment
+constexpr uint32_t kMaximumLength = 1000;
+
 const std::string k_geojson_header = "{\"type\":\"FeatureCollection\",\"features\":[";
 const std::string k_geojson_footer = "]}";
 
@@ -28,8 +36,99 @@ geojson::~geojson() {
 }
 
 void geojson::add_path(const vb::merge::path &p) {
+  // Get the length of the path
+  uint32_t total_length = 0;
+  for (auto edge_id : p.m_edges) {
+    const auto *tile = m_reader.GetGraphTile(edge_id);
+    const auto *edge = tile->directededge(edge_id);
+    total_length += edge->length();
+  }
+
+  // Skip very short segments that are only 1 edge
+  if (total_length < kMinimumLength && p.m_edges.size() == 1) {
+    return;
+  }
+
+  // Split longer segments
+  if (total_length < kMaximumLength) {
+    output_segment(p);
+  } else {
+    split_path(p, total_length);
+  }
+}
+
+void geojson::split_path(const vb::merge::path& p, const uint32_t total_length) {
+  // Walk the merged path and split where needed
+  uint32_t accumulated_length = 0;
+  vb::merge::path split_path(p.m_start);
+  for (auto edge_id : p.m_edges) {
+    // TODO - do we need to check if we enter a new tile or does the writer
+    // handle this?
+
+    const auto* tile = m_reader.GetGraphTile(edge_id);
+    const auto* edge = tile->directededge(edge_id);
+    uint32_t edge_len = edge->length();
+
+    if (edge_len >= kMaximumLength) {
+      // Output prior segment
+      if (split_path.m_edges.size() > 0) {
+        output_segment(split_path);
+      }
+
+      // TODO - split this edge - for now just add the entire edge
+      uint32_t edgeinfo_offset = edge->edgeinfo_offset();
+      auto edgeinfo = tile->edgeinfo(edgeinfo_offset);
+      std::vector<PointLL> shape = tile->edgeinfo(edge->edgeinfo_offset()).shape();
+      if (!edge->forward()) {
+        std::reverse(shape.begin(), shape.end());
+      }
+
+      float shape_length = length(shape);
+
+      // Split the edge
+      int n = (edge_len / kMaximumLength);
+      float dist = static_cast<float>(edge_len) / static_cast<float>(n+1);
+      uint32_t d = std::ceil(dist);
+      for (int i = 0; i < n; i++) {
+       // if (shape.size() == 0) break;
+        auto sub_shape = trim_front(shape, d);
+        output_segment(sub_shape, edge, edge_id);
+      }
+      if (shape.size() > 0) {
+        output_segment(shape, edge, edge_id);
+      }
+
+      // Start a new path at the end of this edge
+      split_path.m_start = edge->endnode();
+      split_path.m_edges.clear();
+      accumulated_length = 0;
+    } else if (accumulated_length + edge_len >= kMaximumLength) {
+      // TODO - optimize the split to avoid short segments
+
+      // Output the current split path and start a new split path
+      output_segment(split_path);
+      split_path.m_start = split_path.m_end;
+      split_path.m_edges.clear();
+      split_path.m_edges.push_back(edge_id);
+      split_path.m_end = edge->endnode();
+      accumulated_length = edge_len;
+    } else {
+      // Add this edge to the new path
+      split_path.m_edges.push_back(edge_id);
+      split_path.m_end = edge->endnode();
+      accumulated_length += edge_len;
+    }
+  }
+
+  // Output the last
+  if (split_path.m_edges.size() > 0) {
+    output_segment(split_path);
+  }
+}
+
+void geojson::output_segment(const vb::merge::path &p) {
   std::ostringstream out;
-  out.precision(17);
+  out.precision(9);
 
   auto tile_id = p.m_start.Tile_Base();
 
@@ -58,21 +157,25 @@ void geojson::add_path(const vb::merge::path &p) {
     if (directededge->classification() < best_frc) {
       best_frc = directededge->classification();
     }
+
+    // Get the edge shape. reverse the order if needed
     auto edgeinfo_offset = directededge->edgeinfo_offset();
-    auto edgeinfo = tile->edgeinfo(edgeinfo_offset);
-    auto decoder = edgeinfo.lazy_shape();
+    std::vector<PointLL> shape = tile->edgeinfo(edgeinfo_offset).shape();
+    if (!directededge->forward()) {
+      std::reverse(shape.begin(), shape.end());
+    }
 
+    // Serialize the shape
     out << "[";
     bool first_pt = true;
-    while (!decoder.empty()) {
+    for (const auto& pt : shape) {
       if (first_pt) { first_pt = false; } else { out << ","; }
-
-      auto pt = decoder.pop();
       out << "[" << pt.lng() << "," << pt.lat() << "]";
     }
     out << "]";
   }
 
+  // Add properties for this OSMLR segment
   vb::GraphId osmlr_id(tile_id.tileid(), tile_id.level(), tile_path_itr->second);
   out << "]},\"properties\":{"
       << "\"tile_id\":" << tile_id.tileid() << ","
@@ -96,6 +199,55 @@ void geojson::add_path(const vb::merge::path &p) {
   tile_path_itr->second += 1;
 }
 
+// Output a segment that is part of an edge.
+void geojson::output_segment(const std::vector<vm::PointLL>& shape,
+                             const vb::DirectedEdge* edge,
+                             const vb::GraphId& edgeid) {
+  std::ostringstream out;
+  out.precision(17);
+
+  auto tile_id = edgeid.Tile_Base();
+
+  auto tile_path_itr = m_tile_path_ids.find(tile_id);
+  if (tile_path_itr == m_tile_path_ids.end()) {
+    out << k_geojson_header;
+    std::tie(tile_path_itr, std::ignore) = m_tile_path_ids.emplace(tile_id, 0);
+  } else {
+    out << ",";
+  }
+
+  out << "{\"type\":\"Feature\",\"geometry\":";
+  out << "{\"type\":\"MultiLineString\",\"coordinates\":[";
+  out << "[";
+  bool first_pt = true;
+  for (const auto pt : shape) {
+    if (first_pt) { first_pt = false; } else { out << ","; }
+    out << "[" << pt.lng() << "," << pt.lat() << "]";
+  }
+  out << "]";
+
+  vb::GraphId osmlr_id(tile_id.tileid(), tile_id.level(), tile_path_itr->second);
+  bool first = true;
+  bool oneway = is_oneway(edge);
+  bool drive_on_right = edge->drive_on_right();
+  vb::RoadClass best_frc = edge->classification();
+  out << "]},\"properties\":{"
+      << "\"tile_id\":" << tile_id.tileid() << ","
+      << "\"level\":" << tile_id.level() << ","
+      << "\"id\":" << tile_path_itr->second << ","
+      << "\"osmlr_id\":" << osmlr_id.value << ","
+      << "\"best_frc\":\"" << vb::to_string(best_frc) << "\","
+      << "\"oneway\":" << oneway << ","
+      << "\"drive_on_right\":" << drive_on_right << ","
+      << "\"original_edges\":\"";
+
+  out << edgeid;
+  out << "\"}}";
+
+  m_writer.write_to(tile_id, out.str());
+  tile_path_itr->second += 1;
+}
+
 void geojson::finish() {
   for (auto entry : m_tile_path_ids) {
     m_writer.write_to(entry.first, k_geojson_footer);