libosrm 1.0.0.pre.rc1

data/ext/libosrm/osrm_match_func.hpp

@@ -0,0 +1,19 @@
+#ifndef OSRM_MATCH_FUNC
+#define OSRM_MATCH_FUNC
+
+#include "globals.hpp"
+
+#include <osrm/osrm.hpp>
+#include <osrm/json_container.hpp>
+
+using namespace Rice;
+
+Rice::Object wrap_match(Rice::Object self, Rice::Array coordinates, Rice::Hash opts);
+
+//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);
+
+Hash parse_match_result(osrm::json::Object match);
+
+#endif

data/ext/libosrm/osrm_nearest_func.cpp

@@ -0,0 +1,80 @@
+
+#include "osrm_nearest_func.hpp"
+
+#include <osrm/nearest_parameters.hpp>
+
+Object wrap_nearest(Object self, double latitude, double longitude, int amount) {
+    NearestFunc func;
+    return func.wrap_nearest(self, latitude, longitude, amount);
+}
+
+Hash NearestFunc::parse_nearest_result(osrm::json::Object nearest) {
+    Hash result;
+    for(std::pair<std::string, osrm::util::json::Value> e : nearest.values) {
+        if(e.first == "code") {
+            result[String("code")] = e.second.get<osrm::json::String>().value;
+        } else if(e.first == "waypoints") {
+            result[String("waypoints")] = parse_waypoints(e.second.get<osrm::json::Array>());
+        } else {
+            throw Exception(rb_eRuntimeError, "Invalid JSON value when building a match from libosrm.so: %s", e.first.c_str());
+        }
+    }
+
+    return result;
+}
+
+Object NearestFunc::wrap_nearest(Object self, double latitude, double longitude, int amount) {
+    // Convert Ruby object to native type
+    osrm::NearestParameters params;
+
+    params.coordinates.push_back({osrm::util::FloatLongitude{longitude}, osrm::util::FloatLatitude{latitude}});
+
+    /*
+    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;
+        }
+    }
+    */
+
+    params.number_of_results = amount;
+
+    // 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->Nearest(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_nearest_result(result);
+}
+

data/ext/libosrm/osrm_nearest_func.hpp

@@ -0,0 +1,25 @@
+#ifndef OSRM_NEAREST_FUNC
+#define OSRM_NEAREST_FUNC
+
+#include "globals.hpp"
+#include "osrm_action.hpp"
+
+#include <osrm/osrm.hpp>
+#include <osrm/json_container.hpp>
+
+using namespace Rice;
+
+Rice::Object wrap_nearest(Rice::Object self, double latitude, double longitude, int amount);
+
+class NearestFunc : private OSRMAction {
+
+public:
+    // amount defaults to 1
+    Rice::Object wrap_nearest(Rice::Object self, double latitude, double longitude, int amount);
+
+private:
+    Hash parse_nearest_result(osrm::json::Object nearest);
+
+};
+
+#endif

data/ext/libosrm/osrm_route_func.cpp

@@ -0,0 +1,86 @@
+
+#include "osrm_route_func.hpp"
+
+#include <osrm/route_parameters.hpp>
+
+Object wrap_route(Object self, Array coordinates, Hash opts) {
+    RouteFunc func;
+    return func.wrap_route(self, coordinates, opts);
+}
+
+template<>
+Object to_ruby<osrm::json::Value>(osrm::json::Value const & x) {
+    if(x.is<osrm::json::String>()) {
+        return String(x.get<osrm::json::String>().value);
+    } else if(x.is<osrm::json::Number>()) {
+        return to_ruby(x.get<osrm::json::Number>().value);
+    } else {
+        throw Exception(rb_eRuntimeError, "Failed to convert osrm::json::Value, from libosrm.so");
+    }
+}
+
+Object RouteFunc::wrap_route(Object self, Array coordinates, Hash opts) {
+    // Convert Ruby object to native type
+    osrm::RouteParameters 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}});
+    }
+
+    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->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());
+    }
+
+    Hash routes_result;
+    routes_result[String("code")] = result.values["code"].get<osrm::json::String>().value;
+
+    Array routes_array;
+    auto &routeValues = result.values["routes"].get<osrm::json::Array>();
+    for(auto const& routeValue : routeValues.values) {
+        routes_array.push(parse_route(routeValue.get<osrm::json::Object>()));
+    }
+    routes_result[String("routes")] = routes_array;
+
+    return routes_result;
+}

data/ext/libosrm/osrm_route_func.hpp

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

data/ext/libosrm/osrm_table_func.cpp

@@ -0,0 +1,101 @@
+
+#include "osrm_table_func.hpp"
+
+#include <osrm/table_parameters.hpp>
+
+#include "osrm_nearest_func.hpp"
+
+Object wrap_table(Object self, Array coordinates, Hash opts) {
+    TableFunc func;
+    return func.wrap_table(self, coordinates, opts);
+}
+
+Hash TableFunc::parse_table_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 == "durations") {
+            Array durations_result;
+            for(auto const& durationArrayValue : e.second.get<osrm::json::Array>().values) {
+                auto durationArray = durationArrayValue.get<osrm::json::Array>();
+                Array duration_result;
+                for(auto const& durationValue : durationArray.values) {
+                    duration_result.push(durationValue.get<osrm::json::Number>().value);
+                }
+                durations_result.push(duration_result);
+            }
+            result[String("durations")] = durations_result;
+        } else if(e.first == "sources") {
+            result[String("sources")] = parse_waypoints(e.second.get<osrm::json::Array>());
+        } else if(e.first == "destinations") {
+            result[String("destinations")] = parse_waypoints(e.second.get<osrm::json::Array>());
+        } else {
+            throw Exception(rb_eRuntimeError, "Invalid JSON value when building a table from libosrm.so: %s", e.first.c_str());
+        }
+    }
+
+    return result;
+}
+
+std::vector<std::size_t> TableFunc::table_array_conversion(Object o) {
+    std::vector<std::size_t> out;
+    if(o.is_a(rb_cArray)) {
+        Array a = (Array) o;
+        Array::iterator it = a.begin();
+        Array::iterator end = a.end();
+        for(; it != end; ++it) {
+            int index = (int)(Object)*it;
+            out.push_back(index);
+        }
+    } else if(o.is_a(rb_cString)) {
+        out.push_back(from_ruby<int>(o));
+    } else if(o.is_a(rb_cNumeric)) {
+        out.push_back(from_ruby<int>(o));
+    }
+
+    return out;
+}
+
+Object TableFunc::wrap_table(Object self, Array coordinates, Hash opts) {
+    // Convert Ruby object to native type
+    osrm::TableParameters 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 sources = opts[Symbol("sources")];
+        if(sources) {
+            params.sources = table_array_conversion(sources);
+        }
+
+        Object destinations = opts[Symbol("destinations")];
+        if(sources) {
+            params.destinations = table_array_conversion(destinations);
+        }
+    }
+
+    // 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->Table(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_table_result(result);
+}

data/ext/libosrm/osrm_table_func.hpp

@@ -0,0 +1,25 @@
+#ifndef OSRM_TABLE_FUNC
+#define OSRM_TABLE_FUNC
+
+#include "globals.hpp"
+#include "osrm_action.hpp"
+
+#include <osrm/osrm.hpp>
+#include <osrm/json_container.hpp>
+
+using namespace Rice;
+
+Rice::Object wrap_table(Object self, Array coordinates, Hash opts);
+
+class TableFunc : private OSRMAction {
+
+public:
+    Rice::Object wrap_table(Object self, Array coordinates, Hash opts);
+
+private:
+    std::vector<std::size_t> table_array_conversion(Object o);
+    Hash parse_table_result(osrm::json::Object match);
+
+};
+
+#endif

data/ext/libosrm/osrm_tile_func.cpp

@@ -0,0 +1,27 @@
+
+#include "osrm_tile_func.hpp"
+
+#include <osrm/tile_parameters.hpp>
+
+Object wrap_tile(Object self, int x, int y, int zoom) {
+    // Convert Ruby object to native type
+    osrm::TileParameters params;
+
+    params.x = x;
+    params.y = y;
+    params.z = zoom;
+
+    // Response is a std::string, instead of JSON stuff that is elsewhere
+    std::string result;
+
+    Data_Object<osrm::OSRM> osrm(self);
+
+    // Execute routing request, this does the heavy lifting
+    const auto status = osrm->Tile(params, result);
+
+    if (status != osrm::Status::Ok) {
+        throw Exception(rb_eRuntimeError, "Failed to get tile data with given input.");
+    }
+
+    return to_ruby(result);
+}

data/ext/libosrm/osrm_tile_func.hpp

@@ -0,0 +1,13 @@
+#ifndef OSRM_TILE_FUNC
+#define OSRM_TILE_FUNC
+
+#include "globals.hpp"
+
+#include <osrm/osrm.hpp>
+#include <osrm/json_container.hpp>
+
+using namespace Rice;
+
+Rice::Object wrap_tile(Rice::Object self, int x, int y, int zoom);
+
+#endif

data/ext/libosrm/osrm_trip_func.cpp

@@ -0,0 +1,109 @@
+
+#include "osrm_trip_func.hpp"
+
+#include <osrm/trip_parameters.hpp>
+
+Object wrap_trip(Object self, Array coordinates, Hash opts) {
+    TripFunc func;
+    return func.wrap_trip(self, coordinates, opts);
+}
+
+Object TripFunc::wrap_trip(Object self, Array coordinates, Hash opts) {
+    // Convert Ruby object to native type
+    osrm::TripParameters 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}});
+    }
+
+    Object roundtrip = opts[Symbol("roundtrip")];
+    if(roundtrip) {
+        params.roundtrip = true;
+    }
+
+    Object source = opts[Symbol("source")];
+    if(!source.is_nil()) {
+        Symbol source_symbol = (Symbol) source;
+        const char *source_string = source_symbol.c_str();
+        if(strcmp(source_string, "any") == 0) {
+            params.source = osrm::TripParameters::SourceType::Any;
+        } else if(strcmp(source_string, "first") == 0) {
+            params.source = osrm::TripParameters::SourceType::First;
+        } else {
+            throw Exception(rb_eRuntimeError, "libosrm.so#wrap_trip(): failed to recognize given source symbol: %s", source_string);
+        }
+    }
+
+    Object destination = opts[Symbol("destination")];
+    if(!destination.is_nil()) {
+        Symbol destination_symbol = (Symbol) destination;
+        const char *destination_string = destination_symbol.c_str();
+        if(strcmp(destination_string, "any") == 0) {
+            params.destination = osrm::TripParameters::DestinationType::Any;
+        } else if(strcmp(destination_string, "last") == 0) {
+            params.destination = osrm::TripParameters::DestinationType::Last;
+        } else {
+            throw Exception(rb_eRuntimeError, "libosrm.so#wrap_trip(): failed to recognize given destination symbol: %s", destination_string);
+        }
+    }
+
+    // TODO: since this option is same as in route thing, maybe we could have some kind of abstraction?
+    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->Trip(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 calculate a trip with given input. error code: %s, message: %s", code.c_str(), message.c_str());
+    }
+
+    Hash trip_result;
+    trip_result[String("code")] = result.values["code"].get<osrm::json::String>().value;
+
+    trip_result[String("waypoints")] = parse_waypoints(result.values["waypoints"].get<osrm::json::Array>());
+
+    Array trips_array;
+    auto &tripValues = result.values["trips"].get<osrm::json::Array>();
+    for(auto const& tripValue : tripValues.values) {
+        trips_array.push(parse_route(tripValue.get<osrm::json::Object>()));
+    }
+    trip_result[String("trips")] = trips_array;
+
+    return trip_result;
+}