libosrm 1.0.0.pre.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cfcb4338e74ba04017eadd08b4ea6f87b1710766
+  data.tar.gz: 07a0cfd4dd83545f2e1ab951fd1b7f45fb139990
+SHA512:
+  metadata.gz: 4d9889352472136de6cccbc235c3b7337aa5dda83fa4df874e437db0a5d19b8777f6386746b6d0e0fa1201556ee3304c1e1c8777d94ace9d803980ff5aba1272
+  data.tar.gz: 6fb73dda9d9b1aabbfa08c6a67a806d7b05204a3c0ed8d4c27543f403f3015de2a4422ad395bfcd4a68f78d28554ac7aceb81afbf48a240873771e2ea2b9d05f

data/bin/libosrm-prepare

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+#require_relative "../lib/libosrm/version"
+
+def print_usage
+  puts "Usage: #{$0} path_to_map.pbf"
+  exit 1
+end
+
+unless ARGV[0]
+  print_usage
+end
+
+pbf = ARGV[0]
+
+if(pbf == "-h" || pbf == "--help")
+  puts "libosrm-prepare is an utility to prepare Openstreetmap map data for ruby-libosrm to use."
+  puts
+  print_usage
+end
+
+unless File.file? pbf
+  puts "Given file does not exist."
+  puts
+  print_usage
+end
+
+result = system "#{__dir__}/../libexec/osrm-extract #{pbf} -p #{__dir__}/../osrm/profiles/car.lua"
+
+unless result
+  puts
+  puts "Extracting map data failed."
+  exit 1
+end
+
+result = system "#{__dir__}/../libexec/osrm-contract #{pbf}"
+
+unless result
+  puts
+  puts "Creating osrm compliant data failed."
+  exit 1
+end

data/ext/libosrm/dependencies.yaml

@@ -0,0 +1,4 @@
+
+libosrm:
+    version: "5.12.0"
+    download_uri: "https://github.com/Project-OSRM/osrm-backend/archive/v5.12.0.tar.gz"

data/ext/libosrm/extconf.rb

@@ -0,0 +1,76 @@
+require "mkmf-rice"
+
+require "fileutils"
+require "yaml"
+
+def do_help
+  print <<HELP
+usage: ruby #{$0} [options]
+
+    --use-system-libraries
+        Use system libraries instead of building and using the bundled
+        libraries.
+HELP
+  exit! 0
+end
+
+case
+when arg_config("--help")
+    do_help
+end
+
+def using_system_libraries?
+    arg_config("--use-system-libraries", !!ENV["LIBOSRM_USE_SYSTEM_LIBRARIES"])
+end
+
+def symlink_osrm_data recipe
+    FileUtils.ln_s "../#{recipe.work_path}/osrm-extract", "libexec/osrm-extract" unless File.exist? "libexec/osrm-extract"
+    FileUtils.ln_s "../#{recipe.work_path}/osrm-contract", "libexec/osrm-contract" unless File.exist? "libexec/osrm-contract"
+    FileUtils.ln_s "../../#{recipe.work_path}/../profiles/car.lua", "osrm/profiles/car.lua" unless File.exist? "osrm/profiles/car.lua"
+end
+
+case
+when using_system_libraries?
+    message "Building ruby-libosrm using system libraries.\n"
+
+    # Using system libraries means we rely on the system libxml2 with
+    # regard to the iconv support.
+
+    dir_config("libosrm").any? or package_config("libosrm")
+
+    append_cflags("-I/usr/include/osrm")
+    have_library "osrm"
+else
+    message "Building ruby-libosrm using packaged libraries.\n"
+
+    #puts Dir.pwd.inspect
+
+    Dir.chdir "#{__dir__}/../.." do
+
+        # The gem version constraint in the Rakefile is not respected at install time.
+        # Keep this version in sync with the one in the Rakefile !
+        require "rubygems"
+        gem "mini_portile2", "~> 2.3.0"
+        require "mini_portile2"
+
+        # Current version doesn’t support out of tree builds
+        require_relative "mini_portile_fixed_cmake"
+
+        deps = YAML.load_file "ext/libosrm/dependencies.yaml"
+
+        recipe = MiniPortileFixedCMake.new("libosrm", deps["libosrm"]["version"])
+        recipe.files = [ deps["libosrm"]["download_uri"] ]
+        recipe.cook
+        recipe.activate
+
+        symlink_osrm_data recipe
+
+        append_cflags("-I#{recipe.path}/include -I#{recipe.path}/include/osrm")
+        find_library "osrm", nil, "#{recipe.path}/lib"
+    end
+end
+
+append_cflags("-DHAVE_CXX11")
+
+#create_makefile "libosrm/libosrm"
+create_makefile "libosrm/ruby_libosrm"

data/ext/libosrm/globals.hpp

@@ -0,0 +1,17 @@
+#ifndef LIBOSRM_GLOBALS_H_
+#define LIBOSRM_GLOBALS_H_
+
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+#include "rice/Enum.hpp"
+#include "rice/Struct.hpp"
+
+using namespace Rice;
+
+static Module rb_mLibOSRM = define_module("LibOSRM");
+
+#define ATTR_ACCESSOR_DECL(klass, variable) \
+    .define_method(#variable, &klass##_##variable##_get) \
+    .define_method(#variable "=", &klass##_##variable##_set)
+
+#endif

data/ext/libosrm/libosrm.cpp

@@ -0,0 +1,23 @@
+
+#include "globals.hpp"
+
+using namespace Rice;
+
+#include "ruby_engine_config.hpp"
+#include "ruby_osrm_object.hpp"
+
+extern "C"
+void Init_ruby_libosrm() {
+    try {
+        //RUBY_TRY
+        //{
+        init_engine_config();
+        init_osrm_object();
+        //}
+        //RUBY_CATCH
+    } catch(...) {
+        std::clog  << "Exception found:" << std::endl;
+        std::exception_ptr p = std::current_exception();
+        std::clog <<(p ? p.__cxa_exception_type()->name() : "null") << std::endl;
+    }
+}

data/ext/libosrm/mini_portile_fixed_cmake.rb

@@ -0,0 +1,51 @@
+require "mini_portile2/mini_portile"
+
+class MiniPortileFixedCMake < MiniPortile
+  def configure_prefix
+    "-DCMAKE_INSTALL_PREFIX=#{File.expand_path(port_path)}"
+  end
+
+  def configure_defaults
+    if MiniPortile.windows?
+      [ '-G "NMake Makefiles"' ]
+    else
+      []
+    end
+  end
+
+  def configure
+    return if configured?
+
+    cache_file = File.join(tmp_path, "configure.options_cache")
+    File.open(cache_file, "w") { |f| f.write computed_options.to_s }
+
+    #execute("configure", %w(cmake) + computed_options + [ "-Bbuild" ] + [ "-H." ])
+    execute("configure", %w(cmake) + computed_options + [ ".." ])
+  end
+
+  def configured?
+    configure = File.join(work_path, "configure")
+    makefile  = File.join(work_path, "CMakefile")
+    cache_file  = File.join(tmp_path, "configure.options_cache")
+
+    stored_options  = File.exist?(cache_file) ? File.read(cache_file) : ""
+    current_options = computed_options.to_s
+
+    (current_options == stored_options) && newer?(makefile, configure)
+  end
+
+  def make_cmd
+    return "nmake" if MiniPortile.windows?
+    super
+  end
+
+  #def tmp_path
+  #    "nya"
+  #end
+
+  def work_path
+      orig = super
+      Dir.mkdir "#{orig}/build" unless Dir.exist? "#{orig}/build"
+      "#{orig}/build"
+  end
+end

data/ext/libosrm/osrm_action.cpp

@@ -0,0 +1,188 @@
+
+#include "osrm_action.hpp"
+
+Array OSRMAction::parse_waypoints(osrm::json::Array waypoints) {
+    Array waypoints_result;
+    for(auto const& waypointValue : waypoints.values) {
+        auto waypoint = waypointValue.get<osrm::json::Object>();
+        Hash waypoint_result;
+        for(std::pair<std::string, osrm::util::json::Value> e : waypoint.values) {
+            if(e.first == "name") {
+                waypoint_result[String("name")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "location") {
+                Hash location;
+                auto const& values = e.second.get<osrm::json::Array>().values;
+                location[Symbol("latitude")] = values[1].get<osrm::json::Number>().value;
+                location[Symbol("longitude")] = values[0].get<osrm::json::Number>().value;
+                waypoint_result[String("location")] = location;
+            } else if(e.first == "hint") {
+                waypoint_result[String("hint")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "distance") {
+                waypoint_result[String("distance")] = e.second.get<osrm::json::Number>().value;
+            } else if(e.first == "waypoint_index") { // Present in trip action
+                waypoint_result[String("waypoint_index")] = e.second.get<osrm::json::Number>().value;
+            } else if(e.first == "trips_index") { // Present in trip action
+                waypoint_result[String("trips_index")] = e.second.get<osrm::json::Number>().value;
+            } else {
+                throw Exception(rb_eRuntimeError, "Invalid JSON value when building waypoints from libosrm.so: %s", e.first.c_str());
+            }
+        }
+
+        waypoints_result.push(waypoint_result);
+    }
+
+    return waypoints_result;
+}
+
+Hash OSRMAction::parse_route(osrm::json::Object route) {
+    Hash route_result;
+    for(std::pair<std::string, osrm::util::json::Value> e : route.values) {
+        if(e.first == "distance") {
+            route_result[String("distance")] = e.second.get<osrm::json::Number>().value;
+        } else if(e.first == "duration") {
+            route_result[String("duration")] = e.second.get<osrm::json::Number>().value;
+        } else if(e.first == "weight") {
+            route_result[String("weight")] = e.second.get<osrm::json::Number>().value;
+        } else if(e.first == "weight_name") {
+            route_result[String("weight_name")] = e.second.get<osrm::json::String>().value;
+        } else if(e.first == "geometry") {
+            route_result[String("geometry")] = e.second.get<osrm::json::String>().value;
+        } else if(e.first == "legs") {
+            route_result[String("legs")] = parse_route_legs(e.second);
+        } else {
+            throw Exception(rb_eRuntimeError, "Invalid JSON value when building a route from libosrm.so: %s", e.first.c_str());
+        }
+    }
+
+    return route_result;
+}
+
+Hash OSRMAction::parse_route_leg_annotations(osrm::util::json::Value value) {
+    auto annotations = value.get<osrm::json::Object>();
+    Hash result;
+    for(std::pair<std::string, osrm::util::json::Value> e : annotations.values) {
+        if(e.first == "distance") {
+            Array values;
+            for(auto const &value : e.second.get<osrm::json::Array>().values) {
+                values.push(to_ruby(value));
+            }
+            result[String("distance")] = values;
+        } else if(e.first == "duration") {
+            Array values;
+            for(auto const &value : e.second.get<osrm::json::Array>().values) {
+                values.push(to_ruby(value));
+            }
+            result[String("duration")] = values;
+        } else if(e.first == "datasources") {
+            Array values;
+            for(auto const &value : e.second.get<osrm::json::Array>().values) {
+                values.push(to_ruby(value));
+            }
+            result[String("datasources")] = values;
+        } else if(e.first == "nodes") {
+            Array values;
+            for(auto const &value : e.second.get<osrm::json::Array>().values) {
+                values.push(to_ruby(value));
+            }
+            result[String("nodes")] = values;
+        } else if(e.first == "weight") {
+            Array values;
+            for(auto const &value : e.second.get<osrm::json::Array>().values) {
+                values.push(to_ruby(value));
+            }
+            result[String("weight")] = values;
+        } else if(e.first == "speed") {
+            Array values;
+            for(auto const &value : e.second.get<osrm::json::Array>().values) {
+                values.push(to_ruby(value));
+            }
+            result[String("speed")] = values;
+        } else  {
+            throw Exception(rb_eRuntimeError, "Invalid JSON value when building a route leg annotations from libosrm.so: %s", e.first.c_str());
+        }
+    }
+
+    return result;
+}
+
+Array OSRMAction::parse_route_leg_steps(osrm::util::json::Value value) {
+    Array steps_array;
+
+    auto &stepsValues = value.get<osrm::json::Array>();
+    for(auto const& stepValue : stepsValues.values) {
+        auto step = stepValue.get<osrm::json::Object>();
+        Hash step_result;
+        for(std::pair<std::string, osrm::util::json::Value> e : step.values) {
+            if(e.first == "distance") {
+                step_result[String("distance")] = e.second.get<osrm::json::Number>().value;
+            } else if(e.first == "duration") {
+                step_result[String("duration")] = e.second.get<osrm::json::Number>().value;
+            } else if(e.first == "weight") {
+                step_result[String("weight")] = e.second.get<osrm::json::Number>().value;
+            } else if(e.first == "geometry") {
+                step_result[String("geometry")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "name") {
+                step_result[String("name")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "ref") {
+                step_result[String("ref")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "pronunciation") {
+                step_result[String("pronunciation")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "destinations") {
+                step_result[String("destinations")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "exits") {
+                step_result[String("exits")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "mode") {
+                step_result[String("mode")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "maneuver") {
+                auto values = e.second.get<osrm::json::Object>().values;
+                Hash maneuver;
+                maneuver[String("modifier")] = values.at("modifier").get<osrm::json::String>().value;
+                maneuver[String("type")] = values.at("type").get<osrm::json::String>().value;
+                step_result[String("maneuver")] = maneuver;
+            } else if(e.first == "intersections") {
+                //step_result[String("intersections")] = e.second.get<osrm::json::String>().value; // TODO
+            } else if(e.first == "rotary_name") {
+                step_result[String("rotary_name")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "rotary_pronunciation") {
+                step_result[String("rotary_pronunciation")] = e.second.get<osrm::json::String>().value;
+            } else {
+                throw Exception(rb_eRuntimeError, "Invalid JSON value when building a route leg steps from libosrm.so: %s", e.first.c_str());
+            }
+        }
+
+        steps_array.push(step_result);
+    }
+
+    return steps_array;
+}
+
+Array OSRMAction::parse_route_legs(osrm::util::json::Value value) {
+    Array legs_array;
+
+    auto &legsValues = value.get<osrm::json::Array>();
+    for(auto const& legValue : legsValues.values) {
+        auto leg = legValue.get<osrm::json::Object>();
+        Hash leg_result;
+        for(std::pair<std::string, osrm::util::json::Value> e : leg.values) {
+            if(e.first == "distance") {
+                leg_result[String("distance")] = e.second.get<osrm::json::Number>().value;
+            } else if(e.first == "duration") {
+                leg_result[String("duration")] = e.second.get<osrm::json::Number>().value;
+            } else if(e.first == "weight") {
+                leg_result[String("weight")] = e.second.get<osrm::json::Number>().value;
+            } else if(e.first == "summary") {
+                leg_result[String("summary")] = e.second.get<osrm::json::String>().value;
+            } else if(e.first == "steps") {
+                leg_result[String("steps")] = parse_route_leg_steps(e.second);
+            } else if(e.first == "annotation") {
+                leg_result[String("annotation")] = parse_route_leg_annotations(e.second);
+            } else {
+                throw Exception(rb_eRuntimeError, "Invalid JSON value when building a route legs from libosrm.so: %s", e.first.c_str());
+            }
+        }
+
+        legs_array.push(leg_result);
+    }
+
+    return legs_array;
+}

data/ext/libosrm/osrm_action.hpp

@@ -0,0 +1,24 @@
+#ifndef OSRM_ACTION
+#define OSRM_ACTION
+
+#include "globals.hpp"
+
+#include <osrm/osrm.hpp>
+#include <osrm/json_container.hpp>
+
+/**
+ * Abstract class implementing some common methods many OSRM actions requires.
+ */
+class OSRMAction {
+
+public:
+    Array parse_waypoints(osrm::json::Array waypoints);
+    Hash parse_route(osrm::json::Object route);
+
+private:
+    Array parse_route_legs(osrm::util::json::Value value);
+    Array parse_route_leg_steps(osrm::util::json::Value value);
+    Hash parse_route_leg_annotations(osrm::util::json::Value value);
+};
+
+#endif

data/ext/libosrm/osrm_match_func.cpp

@@ -0,0 +1,79 @@
+
+#include "osrm_match_func.hpp"
+
+#include <osrm/match_parameters.hpp>
+
+Hash parse_match_result(osrm::json::Object match) {
+    Hash result;
+    for(std::pair<std::string, osrm::util::json::Value> e : match.values) {
+        if(e.first == "code") {
+            result[String("code")] = e.second.get<osrm::json::String>().value;
+        } else if(e.first == "tracepoints") {
+            // TODO
+        } else if(e.first == "matchings") {
+            // TODO
+        } else {
+            throw Exception(rb_eRuntimeError, "Invalid JSON value when building a match from libosrm.so: %s", e.first.c_str());
+        }
+    }
+
+    return result;
+}
+
+Object wrap_match(Object self, Array coordinates, Hash opts) {
+    // Convert Ruby object to native type
+    osrm::MatchParameters params;
+
+    Array::iterator it = coordinates.begin();
+    Array::iterator end = coordinates.end();
+    for(; it != end; ++it) {
+        Hash latlon = (Hash)*it;
+        double lat = from_ruby<double>(latlon[Symbol("latitude")]);
+        double lon = from_ruby<double>(latlon[Symbol("longitude")]);
+        params.coordinates.push_back({osrm::util::FloatLongitude{lon}, osrm::util::FloatLatitude{lat}});
+    }
+
+    if(!opts.is_nil()) {
+        Object geometry_type = opts[Symbol("geometry_type")];
+        if(!geometry_type.is_nil()) {
+            Symbol g_type = (Symbol) geometry_type;
+            const char *type = g_type.c_str();
+            if(strcmp(type, "polyline") == 0) {
+                params.geometries = osrm::RouteParameters::GeometriesType::Polyline;
+            }
+            if(strcmp(type, "polyline6") == 0) {
+                params.geometries = osrm::RouteParameters::GeometriesType::Polyline6;
+            }
+            if(strcmp(type, "geojson") == 0) {
+                params.geometries = osrm::RouteParameters::GeometriesType::GeoJSON;
+            }
+        }
+
+        Object steps = opts[Symbol("steps")];
+        if(steps) {
+            params.steps = true;
+        }
+
+        Object annotations = opts[Symbol("annotations")];
+        if(annotations) {
+            params.annotations = true;
+        }
+    }
+
+    // Response is in JSON format
+    osrm::json::Object result;
+
+    Data_Object<osrm::OSRM> osrm(self);
+
+    // Execute routing request, this does the heavy lifting
+    const auto status = osrm->Match(params, result);
+
+    if (status != osrm::Status::Ok) {
+        const auto code = result.values["code"].get<osrm::json::String>().value;
+        const auto message = result.values["message"].get<osrm::json::String>().value;
+
+        throw Exception(rb_eRuntimeError, "Failed to route with given input. error code: %s, message: %s", code.c_str(), message.c_str());
+    }
+
+    return parse_match_result(result);
+}