libosrm 1.0.0.pre.rc1

data/ext/libosrm/osrm_trip_func.hpp

@@ -0,0 +1,20 @@
+#ifndef OSRM_TRIP_FUNC
+#define OSRM_TRIP_FUNC
+
+#include "globals.hpp"
+#include "osrm_action.hpp"
+
+#include <osrm/osrm.hpp>
+#include <osrm/json_container.hpp>
+
+using namespace Rice;
+
+Rice::Object wrap_trip(Rice::Object self, Rice::Array coordinates, Rice::Hash opts);
+
+class TripFunc : private OSRMAction {
+
+public:
+    Rice::Object wrap_trip(Rice::Object self, Rice::Array coordinates, Rice::Hash opts);
+};
+
+#endif

data/ext/libosrm/ruby_engine_config.cpp

@@ -0,0 +1,89 @@
+
+#include "ruby_engine_config.hpp"
+
+Data_Type<osrm::EngineConfig> rb_cEngineConfig;
+Enum<osrm::EngineConfig::Algorithm> rb_eEngineConfigAlgorithm;
+
+template<>
+osrm::EngineConfig::Algorithm from_ruby<osrm::EngineConfig::Algorithm>(Object x) {
+    Data_Object<osrm::EngineConfig::Algorithm> d(x, rb_eEngineConfigAlgorithm);
+    return *d;
+}
+
+#define EC_ACC_INT(variable) \
+    Object EngineConfig_##variable##_get(Object self) { \
+        Data_Object<osrm::EngineConfig> c(self, rb_cEngineConfig); \
+        return c->variable; \
+    }\
+    \
+    Object EngineConfig_##variable##_set(Object self, Object value) { \
+        Data_Object<osrm::EngineConfig> c(self, rb_cEngineConfig); \
+        c->variable = value.value(); \
+        return value; \
+    }
+
+Object EngineConfig_storage_config_get(Object self) {
+    Data_Object<osrm::EngineConfig> c(self, rb_cEngineConfig);
+    //return c->storage_config;
+    return self;
+}
+
+Object EngineConfig_storage_config_set(Object self, Object value) {
+    Data_Object<osrm::EngineConfig> c(self, rb_cEngineConfig);
+    c->storage_config = from_ruby<osrm::storage::StorageConfig>(value.value());
+    return value;
+}
+
+Object EngineConfig_use_shared_memory_get(Object self) {
+    Data_Object<osrm::EngineConfig> c(self, rb_cEngineConfig);
+    return c->use_shared_memory;
+}
+
+Object EngineConfig_use_shared_memory_set(Object self, Object value) {
+    Data_Object<osrm::EngineConfig> c(self, rb_cEngineConfig);
+    c->use_shared_memory = value.value();
+    return value;
+}
+
+EC_ACC_INT(max_locations_trip)
+EC_ACC_INT(max_locations_viaroute)
+EC_ACC_INT(max_locations_distance_table)
+EC_ACC_INT(max_locations_map_matching)
+EC_ACC_INT(max_results_nearest)
+
+char const * description(osrm::EngineConfig::Algorithm e) {
+    switch(e) {
+        case osrm::EngineConfig::Algorithm::CH:
+            return "Contraction hierarchies";
+        case osrm::EngineConfig::Algorithm::CoreCH:
+            return "Partial contraction hierarchies";
+        case osrm::EngineConfig::Algorithm::MLD:
+            return "Multi level Dijkstra";
+    }
+    return "[invalid]";
+}
+
+void init_engine_config() {
+    rb_cEngineConfig =
+            define_class_under<osrm::EngineConfig>(rb_mLibOSRM, "EngineConfig")
+                .define_constructor(Constructor<osrm::EngineConfig>())
+                .define_method("valid?", &osrm::EngineConfig::IsValid)
+                ATTR_ACCESSOR_DECL(EngineConfig, storage_config)
+                ATTR_ACCESSOR_DECL(EngineConfig, max_locations_trip)
+                ATTR_ACCESSOR_DECL(EngineConfig, max_locations_viaroute)
+                ATTR_ACCESSOR_DECL(EngineConfig, max_locations_distance_table)
+                ATTR_ACCESSOR_DECL(EngineConfig, max_locations_map_matching)
+                ATTR_ACCESSOR_DECL(EngineConfig, max_results_nearest)
+                ATTR_ACCESSOR_DECL(EngineConfig, use_shared_memory)
+            ;
+
+    rb_eEngineConfigAlgorithm =
+      define_enum<osrm::EngineConfig::Algorithm>("Algorithm", rb_cEngineConfig)
+      .define_value("CH", osrm::EngineConfig::Algorithm::CH)
+      .define_value("CoreCH", osrm::EngineConfig::Algorithm::CoreCH)
+      .define_value("MLD", osrm::EngineConfig::Algorithm::MLD);
+
+    rb_eEngineConfigAlgorithm.define_method("description", description);
+
+    init_storage_config();
+}

data/ext/libosrm/ruby_engine_config.hpp

@@ -0,0 +1,26 @@
+#ifndef RUBY_ENGINE_CONFIG_HPP_
+#define RUBY_ENGINE_CONFIG_HPP_
+
+#include "globals.hpp"
+
+#include "ruby_storage_config.hpp"
+
+using namespace Rice;
+
+#include "osrm/engine_config.hpp"
+
+// EngineConfig.storage_config
+Object EngineConfig_storage_config_get(Object self);
+
+// EngineConfig.storage_config
+Object EngineConfig_storage_config_set(Object self, Object value);
+
+Object EngineConfig_use_shared_memory_get(Object self);
+
+Object EngineConfig_use_shared_memory_set(Object self, Object value);
+
+char const * description(osrm::EngineConfig::Algorithm e);
+
+void init_engine_config();
+
+#endif

data/ext/libosrm/ruby_osrm_object.cpp

@@ -0,0 +1,78 @@
+
+#include "ruby_osrm_object.hpp"
+#include "osrm_match_func.hpp"
+#include "osrm_nearest_func.hpp"
+#include "osrm_route_func.hpp"
+#include "osrm_tile_func.hpp"
+#include "osrm_table_func.hpp"
+#include "osrm_trip_func.hpp"
+
+using namespace Rice;
+
+Data_Type<osrm::OSRM> rb_cOsrm;
+
+template<>
+osrm::engine::EngineConfig from_ruby<osrm::engine::EngineConfig>(Object x) {
+    if(x.is_nil()) {
+        // TODO: raise error
+    }
+
+    osrm::engine::EngineConfig config;
+    config.storage_config = { x.to_s().c_str() };
+    config.use_shared_memory = false;
+    return config;
+}
+
+Object wrap_distance_by_roads(Object self, Object o) {
+
+    // Convert Ruby object to native type
+    osrm::RouteParameters params;
+
+    Array coordinates = o;
+    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}});
+    }
+
+    params.overview = osrm::RouteParameters::OverviewType::False;
+
+    // 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->Route(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());
+    }
+
+    // We can take first route since we only want the distance.
+    auto &routes = result.values["routes"].get<osrm::json::Array>();
+    auto &route = routes.values.at(0).get<osrm::json::Object>();
+
+    const auto distance = route.values["distance"].get<osrm::json::Number>().value;
+
+    return to_ruby(distance);
+}
+
+void init_osrm_object() {
+    rb_cOsrm = define_class_under<osrm::OSRM>(rb_mLibOSRM, "OSRM")
+                .define_constructor(Constructor<osrm::OSRM, osrm::EngineConfig>(), Arg("config"))
+                .define_method("distance_by_roads", &wrap_distance_by_roads)
+                .define_method("route", &wrap_route, (Arg("coordinates"), Arg("opts") = Nil))
+                .define_method("table", &wrap_table, (Arg("coordinates"), Arg("opts") = Nil))
+                .define_method("nearest", &wrap_nearest, (Arg("latitude"), Arg("longitude"), Arg("amount") = 1))
+                .define_method("trip", &wrap_trip, (Arg("coordinates"), Arg("opts") = Nil))
+                .define_method("match", &wrap_match, (Arg("coordinates"), Arg("opts") = Nil))
+                .define_method("tile", &wrap_tile, (Arg("x"), Arg("y"), Arg("zoom")))
+            ;
+}

data/ext/libosrm/ruby_osrm_object.hpp

@@ -0,0 +1,20 @@
+#ifndef RUBY_OSRM_OBJECT_H_
+#define RUBY_OSRM_OBJECT_H_
+
+#include "globals.hpp"
+
+using namespace Rice;
+
+#include <osrm/osrm.hpp>
+
+#include <osrm/engine_config.hpp>
+
+#include <osrm/table_parameters.hpp>
+#include <osrm/trip_parameters.hpp>
+#include <osrm/json_container.hpp>
+
+Object wrap_distance_by_roads(Object self, Object o);
+
+void init_osrm_object();
+
+#endif

data/ext/libosrm/ruby_storage_config.cpp

@@ -0,0 +1,86 @@
+
+#include "ruby_storage_config.hpp"
+
+
+Data_Type<osrm::storage::StorageConfig> rb_cStorageConfig;
+
+template<>
+Object to_ruby<boost::filesystem::path>(boost::filesystem::path const & x) {
+    String s(x.c_str());
+    return s;
+}
+
+template<>
+boost::filesystem::path from_ruby<boost::filesystem::path>(Object x) {
+    return x.to_s().c_str();
+}
+
+#define SC_ACC(variable) \
+    Object StorageConfig_##variable##_get(Object self) { \
+        Data_Object<osrm::storage::StorageConfig> c(self, rb_cStorageConfig); \
+        Object o = to_ruby(c->variable); \
+        return o; \
+    }\
+    \
+    Object StorageConfig_##variable##_set(Object self, Object value) { \
+        Data_Object<osrm::storage::StorageConfig> c(self, rb_cStorageConfig); \
+        c->variable = value.to_s().c_str(); \
+        return value; \
+    }
+
+    /*
+SC_ACC(ram_index_path)
+SC_ACC(file_index_path)
+SC_ACC(hsgr_data_path)
+SC_ACC(node_based_nodes_data_path)
+SC_ACC(edge_based_nodes_data_path)
+SC_ACC(edges_data_path)
+SC_ACC(core_data_path)
+SC_ACC(geometries_path)
+SC_ACC(timestamp_path)
+SC_ACC(turn_weight_penalties_path)
+SC_ACC(turn_duration_penalties_path)
+SC_ACC(datasource_names_path)
+SC_ACC(datasource_indexes_path)
+SC_ACC(names_data_path)
+SC_ACC(properties_path)
+SC_ACC(intersection_class_path)
+SC_ACC(turn_lane_data_path)
+SC_ACC(turn_lane_description_path)
+SC_ACC(mld_partition_path)
+SC_ACC(mld_storage_path)
+SC_ACC(mld_graph_path)
+*/
+
+void init_storage_config() {
+    rb_cStorageConfig =
+            define_class_under<osrm::storage::StorageConfig>(rb_mLibOSRM, "StorageConfig")
+                .define_constructor(Constructor<osrm::storage::StorageConfig>())
+                .define_constructor(Constructor<osrm::storage::StorageConfig, const boost::filesystem::path>(), Arg("base"))
+                .define_method("valid?", &osrm::storage::StorageConfig::IsValid)
+                /*ATTR_ACCESSOR_DECL(StorageConfig, ram_index_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, file_index_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, hsgr_data_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, node_based_nodes_data_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, edge_based_nodes_data_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, edges_data_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, core_data_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, geometries_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, timestamp_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, turn_weight_penalties_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, turn_duration_penalties_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, datasource_names_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, datasource_indexes_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, names_data_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, properties_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, intersection_class_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, turn_lane_data_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, turn_lane_description_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, mld_partition_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, mld_storage_path)
+                ATTR_ACCESSOR_DECL(StorageConfig, mld_graph_path)
+                */
+            ;
+
+
+}

data/ext/libosrm/ruby_storage_config.hpp

@@ -0,0 +1,25 @@
+#ifndef RUBY_STORAGE_CONFIG_H_
+#define RUBY_STORAGE_CONFIG_H_
+
+#include "globals.hpp"
+#include "rice/String.hpp"
+
+#include "osrm/storage_config.hpp"
+
+using namespace Rice;
+
+/*
+template<>
+osrm::storage::StorageConfig from_ruby<osrm::storage::StorageConfig>(Object x) {
+  // ...
+}
+
+template<>
+Object to_ruby<osrm::storage::StorageConfig>(osrm::storage::StorageConfig const & x) {
+
+}
+*/
+
+void init_storage_config();
+
+#endif

data/lib/libosrm.rb

@@ -0,0 +1,12 @@
+
+require_relative "libosrm/version"
+
+#require "libosrm/ruby_libosrm"
+require_relative "libosrm/ruby_libosrm"
+#require "ruby-libosrm"
+
+# LibOSRM module contains {OSRM} class, which contains public methods for using OSRM.
+#
+# For general instructions, please see {file:README.md}. For API documentation, please see {OSRM}.
+module LibOSRM
+end

data/lib/libosrm/osrm.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "../libosrm"
+
+# OSRM routing interface.
+#
+# Provides methods to calculate various data using Openstreetmap data with OSRM.
+#
+# For example, to get distance by roads, you could use
+#
+#   osrm = OSRM.new "map.osrm"
+#   distance = osrm.distance_by_roads { latitude: 60.1681473, longitude: 24.9417190 }, { latitude: 60.1694561, longitude: 24.9385663 }
+#
+# Please see {file:README.md} for general instructions of how to use this gem.
+class LibOSRM::OSRM
+
+  # @!macro [new] native
+  #   @note This method is implemented in native code.
+
+  # @!macro [new] api_method
+  #   @note This method is a wrapper for OSRM’s API.
+  #     Please see the {http://project-osrm.org/docs/v5.10.0/api HTTP API} for documentation of response values.
+  #
+  #     Any differences should be documented in corresponding methods;
+  #     please report should you find any.
+
+  # @!macro [new] api_method_return
+  #   @return [Hash] Hash of response data as documented at {http://project-osrm.org/docs/v5.10.0/api HTTP API}
+
+  # @!macro [new] coordinates_param
+  #   @param coordinates [Array] Array of coordinates. See {#distance_by_roads} for an example.
+
+  # @!method initialize(osrm_file)
+  #   @!macro native
+  #   Initializes OSRM object for routing actions.
+  #
+  #   @param osrm_file [String] Path to the OSRM file.
+
+  # @!method distance_by_roads(coordinates)
+  #   @!macro native
+  #
+  #   Calculates distance by roads from given coordinates.
+  #
+  #   Internally operates by invoking {#route}, but
+  #   this method is implemented in native code so this works faster
+  #   than {#route} if you only need distance and no other data.
+  #
+  #   @example Input coordinates array
+  #     [
+  #       { latitude: from_lat, longitude: from_lon },
+  #       { latitude: to_lat, longitude: to_lon }
+  #     ]
+  #
+  #   @param coordinates [Array] Array of coordinate hashes
+  #   @return Float distance by roads in meters
+
+  # @!method route(coordinates, opts = nil)
+  #   @!macro native
+  #   @!macro api_method
+  #
+  #   OSRM routing action. Takes two or more coordinate pairs and calculates distance
+  #   by roads between them. A successful response contains an array of resulting routing data, between each
+  #   point in the request.
+  #
+  #   @note If you only want to know distance by roads for the trip, use {#distance_by_roads} instead.
+  #
+  #   @!macro coordinates_param
+  #   @param opts [Hash] Options to customize the request.
+  #   @option opts [Symbol] :geometry_type Format in which the geometries will be returned at. Possible values: :polyline, :polyline6, :geojson. Defaults to :polyline.
+  #   @option opts [Boolean] :steps Whether steps should be included in response
+  #   @option opts [Boolean] :annotations Whether annotations should be included in response
+  #
+  #   @!macro api_method_return
+
+  # @!method table(coordinates, opts = nil)
+  #   @!macro native
+  #   @!macro api_method
+  #
+  #   OSRM table action. Takes a list of coordinate pairs and calculates distances between each pair to all other pairs.
+  #   The calculations can be customized by sources and destinations parameters. By default full table is calculated.
+  #
+  #   @!macro coordinates_param
+  #   @param opts [Hash] Options to customize the request.
+  #   @option opts [Array] :sources List of indices of coordinates array that should be used as a source location
+  #   @option opts [Array] :destinations List of indices of coordinates array that should be used as a destination location
+  #
+  #   @!macro api_method_return
+
+  # @!method nearest(latitude, longitude, amount = 1)
+  #   @!macro native
+  #   @!macro api_method
+  #
+  #   OSRM nearest action. Returns nearest street network points.
+  #
+  #   @param latitude [Float] Source position’s latitude
+  #   @param longitude [Float] Source position’s longitude
+  #   @param amount [Integer] Amount of nearest entries to be returned
+  #
+  #   @!macro api_method_return
+
+  # @!method trip(coordinates)
+  #   @!macro native
+  #   @!macro api_method
+  #
+  #   Tries to calculate shortest possible route between given coordinates (and then back to original point;
+  #   i.e. the first coordinate pair in the input), in order to solve the travelling salesman problem.
+  #
+  #   @!macro coordinates_param
+  #
+  #   @!macro api_method_return
+
+  # @!method match(coordinates, opts = nil)
+  #   @!macro native
+  #   @!macro api_method
+  #
+  #   Tries to match given coordinates to road network in most plausible way.
+  #
+  #   @todo This action most likely does not work as expected.
+  #
+  #   @!macro coordinates_param
+  #
+  #   @!macro api_method_return
+
+  # @!method tile(x, y, zoom)
+  #   @!macro native
+  #   @!macro api_method
+  #
+  #   Calculates a vector tile image that can be used to examine the routing graph. See the official documentation
+  #   for more comprehensive documentation about this feature.
+  #
+  #   @note You should most likely use {#tile_with_coordinates} instead.
+  #
+  #   @param x [Integer] Tile index as documented at https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
+  #   @param y [Integer] Tile index as documented at https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
+  #   @param zoom [Integer] Map zoom level to generate the tile data
+  #
+  #   @!macro api_method_return
+
+  # Invokes {#tile}, but first converts given coordinates to tile numbers.
+  #
+  # @param latitude [Float] Latitude of the location to get the tile data for
+  # @param longitude [Float] Longitude of the location to get the tile data for
+  # @param zoom [Integer] Map zoom level for the tile image. Controls size of the image.
+  def tile_with_coordinates latitude, longitude, zoom
+    xy = coordinates_to_tile_numbers latitude, longitude, zoom
+    tile xy[:x], xy[:y], zoom
+  end
+
+  # Converts coordinates to tile numbers as expected by {#tile}.
+  #
+  # @param latitude [Float] Latitude of the location to get the tile data for
+  # @param longitude [Float] Longitude of the location to get the tile data for
+  # @param zoom [Integer] Map zoom level for the tile image. Controls size of the image.
+  def coordinates_to_tile_numbers latitude, longitude, zoom
+    lat_rad = latitude / 180 * Math::PI
+    n = 2.0 ** zoom
+    x = ((longitude + 180.0) / 360.0 * n).to_i
+    y = ((1.0 - Math::log(Math::tan(lat_rad) + (1 / Math::cos(lat_rad))) / Math::PI) / 2.0 * n).to_i
+
+    {:x => x, :y =>y}
+  end
+end