Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Update in-tree libosmium dependency to 2.5.4

Browse Source 
The latest releases have some critical fixes, see the changelog:
https://github.com/osmcode/libosmium/blob/v2.5.4/CHANGELOG.md

Merge commit 'afdf8e7b21fbaf597e91d9d8a7542635e60ee9a1' into use_libosmium_2_5_4
This commit is contained in:
Daniel J. Hofmann
2016-01-05 12:00:40 +01:00
parent 9852b147f8 afdf8e7b21
commit d516e1c736
171 changed files with 7150 additions and 3988 deletions
Download Patch File Download Diff File Expand all files Collapse all files
third_party/libosmium/test/data-tests/CMakeLists.txt
Vendored
+3 -3
View File
@@ -88,11 +88,11 @@ set_tests_properties(testdata-overview PROPERTIES
#
#-----------------------------------------------------------------------------
find_package(Ruby 1.9)
find_program(RUBY ruby)
find_package(Gem COMPONENTS json)
find_program(SPATIALITE spatialite)
if(RUBY_FOUND AND GEM_json_FOUND AND SPATIALITE)
if(RUBY AND GEM_json_FOUND AND SPATIALITE)
add_executable(testdata-multipolygon testdata-multipolygon.cpp)
target_link_libraries(testdata-multipolygon
${OSMIUM_XML_LIBRARIES}
@@ -102,7 +102,7 @@ if(RUBY_FOUND AND GEM_json_FOUND AND SPATIALITE)
add_test(NAME testdata-multipolygon
COMMAND ${CMAKE_COMMAND}
-D OSM_TESTDATA=${OSM_TESTDATA}
-D RUBY=${RUBY_EXECUTABLE}
-D RUBY=${RUBY}
-P ${CMAKE_CURRENT_SOURCE_DIR}/run-testdata-multipolygon.cmake)
set_tests_properties(testdata-multipolygon PROPERTIES LABELS "data;slow")
third_party/libosmium/test/data-tests/testdata-multipolygon.cpp
Vendored
+31 -140
View File
@@ -3,6 +3,8 @@
#include <fstream>
#include <map>
#include <gdalcpp.hpp>
#include <osmium/index/map/sparse_mem_array.hpp>
#include <osmium/area/assembler.hpp>
@@ -41,10 +43,9 @@ inline tagmap_type create_map(const osmium::TagList& taglist) {
class TestHandler : public osmium::handler::Handler {
OGRDataSource* m_data_source;
OGRLayer* m_layer_point;
OGRLayer* m_layer_linestring;
OGRLayer* m_layer_polygon;
gdalcpp::Layer m_layer_point;
gdalcpp::Layer m_layer_lines;
gdalcpp::Layer m_layer_mpoly;
osmium::geom::OGRFactory<> m_ogr_factory;
osmium::geom::WKTFactory<> m_wkt_factory;
@@ -55,84 +56,20 @@ class TestHandler : public osmium::handler::Handler {
public:
TestHandler(OGRDataSource* data_source) :
m_data_source(data_source),
explicit TestHandler(gdalcpp::Dataset& dataset) :
m_layer_point(dataset, "points", wkbPoint),
m_layer_lines(dataset, "lines", wkbLineString),
m_layer_mpoly(dataset, "multipolygons", wkbMultiPolygon),
m_out("multipolygon-tests.json") {
OGRSpatialReference sparef;
sparef.SetWellKnownGeogCS("WGS84");
m_layer_point.add_field("id", OFTReal, 10);
m_layer_point.add_field("type", OFTString, 30);
/**************/
m_layer_lines.add_field("id", OFTReal, 10);
m_layer_lines.add_field("type", OFTString, 30);
m_layer_point = m_data_source->CreateLayer("points", &sparef, wkbPoint, nullptr);
if (!m_layer_point) {
std::cerr << "Layer creation failed.\n";
exit(1);
}
OGRFieldDefn layer_point_field_id("id", OFTReal);
layer_point_field_id.SetWidth(10);
if (m_layer_point->CreateField(&layer_point_field_id) != OGRERR_NONE) {
std::cerr << "Creating id field failed.\n";
exit(1);
}
OGRFieldDefn layer_point_field_type("type", OFTString);
layer_point_field_type.SetWidth(30);
if (m_layer_point->CreateField(&layer_point_field_type) != OGRERR_NONE) {
std::cerr << "Creating type field failed.\n";
exit(1);
}
/**************/
m_layer_linestring = m_data_source->CreateLayer("lines", &sparef, wkbLineString, nullptr);
if (!m_layer_linestring) {
std::cerr << "Layer creation failed.\n";
exit(1);
}
OGRFieldDefn layer_linestring_field_id("id", OFTReal);
layer_linestring_field_id.SetWidth(10);
if (m_layer_linestring->CreateField(&layer_linestring_field_id) != OGRERR_NONE) {
std::cerr << "Creating id field failed.\n";
exit(1);
}
OGRFieldDefn layer_linestring_field_type("type", OFTString);
layer_linestring_field_type.SetWidth(30);
if (m_layer_linestring->CreateField(&layer_linestring_field_type) != OGRERR_NONE) {
std::cerr << "Creating type field failed.\n";
exit(1);
}
/**************/
m_layer_polygon = m_data_source->CreateLayer("multipolygons", &sparef, wkbMultiPolygon, nullptr);
if (!m_layer_polygon) {
std::cerr << "Layer creation failed.\n";
exit(1);
}
OGRFieldDefn layer_polygon_field_id("id", OFTInteger);
layer_polygon_field_id.SetWidth(10);
if (m_layer_polygon->CreateField(&layer_polygon_field_id) != OGRERR_NONE) {
std::cerr << "Creating id field failed.\n";
exit(1);
}
OGRFieldDefn layer_polygon_field_from_type("from_type", OFTString);
layer_polygon_field_from_type.SetWidth(1);
if (m_layer_polygon->CreateField(&layer_polygon_field_from_type) != OGRERR_NONE) {
std::cerr << "Creating from_type field failed.\n";
exit(1);
}
m_layer_mpoly.add_field("id", OFTReal, 10);
m_layer_mpoly.add_field("from_type", OFTString, 1);
}
~TestHandler() {
@@ -140,34 +77,18 @@ public:
}
void node(const osmium::Node& node) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_point->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_ogr_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
feature->SetField("type", node.tags().get_value_by_key("type"));
if (m_layer_point->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
gdalcpp::Feature feature(m_layer_point, m_ogr_factory.create_point(node));
feature.set_field("id", static_cast<double>(node.id()));
feature.set_field("type", node.tags().get_value_by_key("type"));
feature.add_to_layer();
}
void way(const osmium::Way& way) {
try {
std::unique_ptr<OGRLineString> ogr_linestring = m_ogr_factory.create_linestring(way);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_linestring->GetLayerDefn());
feature->SetGeometry(ogr_linestring.get());
feature->SetField("id", static_cast<double>(way.id()));
feature->SetField("type", way.tags().get_value_by_key("type"));
if (m_layer_linestring->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
gdalcpp::Feature feature(m_layer_lines, m_ogr_factory.create_linestring(way));
feature.set_field("id", static_cast<double>(way.id()));
feature.set_field("type", way.tags().get_value_by_key("type"));
feature.add_to_layer();
} catch (osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for way " << way.id() << ".\n";
}
@@ -200,10 +121,8 @@ public:
m_out << "INVALID\"\n}";
}
try {
std::unique_ptr<OGRMultiPolygon> ogr_polygon = m_ogr_factory.create_multipolygon(area);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_polygon->GetLayerDefn());
feature->SetGeometry(ogr_polygon.get());
feature->SetField("id", static_cast<int>(area.orig_id()));
gdalcpp::Feature feature(m_layer_mpoly, m_ogr_factory.create_multipolygon(area));
feature.set_field("id", static_cast<double>(area.orig_id()));
std::string from_type;
if (area.from_way()) {
@@ -211,14 +130,8 @@ public:
} else {
from_type = "r";
}
feature->SetField("from_type", from_type.c_str());
if (m_layer_polygon->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
feature.set_field("from_type", from_type.c_str());
feature.add_to_layer();
} catch (osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for area " << area.id() << " created from " << (area.from_way() ? "way" : "relation") << " with id=" << area.orig_id() << ".\n";
}
@@ -228,26 +141,6 @@ public:
/* ================================================== */
OGRDataSource* initialize_database(const std::string& output_format, const std::string& output_filename) {
OGRRegisterAll();
OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(output_format.c_str());
if (!driver) {
std::cerr << output_format << " driver not available.\n";
exit(1);
}
CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
const char* options[] = { "SPATIALITE=TRUE", nullptr };
OGRDataSource* data_source = driver->CreateDataSource(output_filename.c_str(), const_cast<char**>(options));
if (!data_source) {
std::cerr << "Creation of output file failed.\n";
exit(1);
}
return data_source;
}
int main(int argc, char* argv[]) {
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " INFILE\n";
@@ -258,9 +151,10 @@ int main(int argc, char* argv[]) {
std::string input_filename(argv[1]);
std::string output_filename("multipolygon.db");
OGRDataSource* data_source = initialize_database(output_format, output_filename);
CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
gdalcpp::Dataset dataset{output_format, output_filename, gdalcpp::SRS{}, { "SPATIALITE=TRUE" }};
osmium::area::ProblemReporterOGR problem_reporter(data_source);
osmium::area::ProblemReporterOGR problem_reporter(dataset);
osmium::area::Assembler::config_type assembler_config(&problem_reporter);
assembler_config.enable_debug_output();
osmium::area::MultipolygonCollector<osmium::area::Assembler> collector(assembler_config);
@@ -275,7 +169,7 @@ int main(int argc, char* argv[]) {
location_handler_type location_handler(index);
location_handler.ignore_errors();
TestHandler test_handler(data_source);
TestHandler test_handler(dataset);
std::cerr << "Pass 2...\n";
osmium::io::Reader reader2(input_filename);
@@ -284,8 +178,5 @@ int main(int argc, char* argv[]) {
}));
reader2.close();
std::cerr << "Pass 2 done\n";
OGRDataSource::DestroyDataSource(data_source);
OGRCleanupAll();
}
third_party/libosmium/test/data-tests/testdata-overview.cpp
Vendored
+29 -125
View File
@@ -2,6 +2,8 @@
#include <iostream>
#include <gdalcpp.hpp>
#include <osmium/index/map/sparse_mem_array.hpp>
#include <osmium/geom/ogr.hpp>
@@ -15,154 +17,53 @@ typedef osmium::handler::NodeLocationsForWays<index_type> location_handler_type;
class TestOverviewHandler : public osmium::handler::Handler {
OGRDataSource* m_data_source;
OGRLayer* m_layer_nodes;
OGRLayer* m_layer_labels;
OGRLayer* m_layer_ways;
gdalcpp::Layer m_layer_nodes;
gdalcpp::Layer m_layer_labels;
gdalcpp::Layer m_layer_ways;
osmium::geom::OGRFactory<> m_factory;
public:
TestOverviewHandler(const std::string& driver_name, const std::string& filename) {
explicit TestOverviewHandler(gdalcpp::Dataset& dataset) :
m_layer_nodes(dataset, "nodes", wkbPoint),
m_layer_labels(dataset, "labels", wkbPoint),
m_layer_ways(dataset, "ways", wkbLineString) {
OGRRegisterAll();
m_layer_nodes.add_field("id", OFTReal, 10);
OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name.c_str());
if (!driver) {
std::cerr << driver_name << " driver not available.\n";
exit(1);
}
m_layer_labels.add_field("id", OFTReal, 10);
m_layer_labels.add_field("label", OFTString, 30);
CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
const char* options[] = { "SPATIALITE=TRUE", nullptr };
m_data_source = driver->CreateDataSource(filename.c_str(), const_cast<char**>(options));
if (!m_data_source) {
std::cerr << "Creation of output file failed.\n";
exit(1);
}
OGRSpatialReference sparef;
sparef.SetWellKnownGeogCS("WGS84");
// nodes layer
m_layer_nodes = m_data_source->CreateLayer("nodes", &sparef, wkbPoint, nullptr);
if (!m_layer_nodes) {
std::cerr << "Layer creation failed.\n";
exit(1);
}
OGRFieldDefn layer_nodes_field_id("id", OFTReal);
layer_nodes_field_id.SetWidth(10);
if (m_layer_nodes->CreateField(&layer_nodes_field_id) != OGRERR_NONE) {
std::cerr << "Creating id field failed.\n";
exit(1);
}
// labels layer
m_layer_labels = m_data_source->CreateLayer("labels", &sparef, wkbPoint, nullptr);
if (!m_layer_labels) {
std::cerr << "Layer creation failed.\n";
exit(1);
}
OGRFieldDefn layer_labels_field_id("id", OFTReal);
layer_labels_field_id.SetWidth(10);
if (m_layer_labels->CreateField(&layer_labels_field_id) != OGRERR_NONE) {
std::cerr << "Creating id field failed.\n";
exit(1);
}
OGRFieldDefn layer_labels_field_label("label", OFTString);
layer_labels_field_label.SetWidth(30);
if (m_layer_labels->CreateField(&layer_labels_field_label) != OGRERR_NONE) {
std::cerr << "Creating label field failed.\n";
exit(1);
}
// ways layer
m_layer_ways = m_data_source->CreateLayer("ways", &sparef, wkbLineString, nullptr);
if (!m_layer_ways) {
std::cerr << "Layer creation failed.\n";
exit(1);
}
OGRFieldDefn layer_way_field_id("id", OFTReal);
layer_way_field_id.SetWidth(10);
if (m_layer_ways->CreateField(&layer_way_field_id) != OGRERR_NONE) {
std::cerr << "Creating id field failed.\n";
exit(1);
}
OGRFieldDefn layer_way_field_test("test", OFTInteger);
layer_way_field_test.SetWidth(3);
if (m_layer_ways->CreateField(&layer_way_field_test) != OGRERR_NONE) {
std::cerr << "Creating test field failed.\n";
exit(1);
}
}
~TestOverviewHandler() {
OGRDataSource::DestroyDataSource(m_data_source);
OGRCleanupAll();
m_layer_ways.add_field("id", OFTReal, 10);
m_layer_ways.add_field("test", OFTInteger, 3);
}
void node(const osmium::Node& node) {
const char* label = node.tags().get_value_by_key("label");
if (label) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_labels->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
feature->SetField("label", label);
if (m_layer_labels->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
gdalcpp::Feature feature(m_layer_labels, m_factory.create_point(node));
feature.set_field("id", static_cast<double>(node.id()));
feature.set_field("label", label);
feature.add_to_layer();
} else {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_nodes->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
if (m_layer_nodes->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
gdalcpp::Feature feature(m_layer_nodes, m_factory.create_point(node));
feature.set_field("id", static_cast<double>(node.id()));
feature.add_to_layer();
}
}
void way(const osmium::Way& way) {
try {
std::unique_ptr<OGRLineString> ogr_linestring = m_factory.create_linestring(way);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_ways->GetLayerDefn());
feature->SetGeometry(ogr_linestring.get());
feature->SetField("id", static_cast<double>(way.id()));
gdalcpp::Feature feature(m_layer_ways, m_factory.create_linestring(way));
feature.set_field("id", static_cast<double>(way.id()));
const char* test = way.tags().get_value_by_key("test");
if (test) {
feature->SetField("test", test);
feature.set_field("test", test);
}
if (m_layer_ways->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
feature.add_to_layer();
} catch (osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for way " << way.id() << ".\n";
}
@@ -183,13 +84,16 @@ int main(int argc, char* argv[]) {
std::string output_filename("testdata-overview.db");
::unlink(output_filename.c_str());
CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
gdalcpp::Dataset dataset(output_format, output_filename, gdalcpp::SRS{}, { "SPATIALITE=TRUE" });
osmium::io::Reader reader(input_filename);
index_type index;
location_handler_type location_handler(index);
location_handler.ignore_errors();
TestOverviewHandler handler(output_format, output_filename);
TestOverviewHandler handler(dataset);
osmium::apply(reader, location_handler, handler);
reader.close();
third_party/libosmium/test/data-tests/testdata-xml.cpp
Vendored
+20 -15
View File
@@ -8,6 +8,7 @@
#include <iostream>
#include <string>
#include <osmium/io/detail/queue_util.hpp>
#include <osmium/io/xml_input.hpp>
#include <osmium/io/gzip_compression.hpp>
#include <osmium/visitor.hpp>
@@ -72,24 +73,27 @@ std::string read_gz_file(const char* test_id, const char* suffix) {
header_buffer_type parse_xml(std::string input) {
osmium::thread::Queue<std::string> input_queue;
osmium::thread::Queue<osmium::memory::Buffer> output_queue;
osmium::io::detail::future_string_queue_type input_queue;
osmium::io::detail::future_buffer_queue_type output_queue;
std::promise<osmium::io::Header> header_promise;
std::atomic<bool> done {false};
input_queue.push(input);
input_queue.push(std::string()); // EOF marker
std::future<osmium::io::Header> header_future = header_promise.get_future();
osmium::io::detail::XMLParser parser(input_queue, output_queue, header_promise, osmium::osm_entity_bits::all, done);
parser();
osmium::io::detail::add_to_queue(input_queue, std::move(input));
osmium::io::detail::add_to_queue(input_queue, std::string{});
osmium::io::detail::XMLParser parser(input_queue, output_queue, header_promise, osmium::osm_entity_bits::all);
parser.parse();
header_buffer_type result;
result.header = header_promise.get_future().get();
output_queue.wait_and_pop(result.buffer);
result.header = header_future.get();
std::future<osmium::memory::Buffer> future_buffer;
output_queue.wait_and_pop(future_buffer);
result.buffer = future_buffer.get();
if (result.buffer) {
osmium::memory::Buffer buffer;
output_queue.wait_and_pop(buffer);
assert(!buffer);
std::future<osmium::memory::Buffer> future_buffer2;
output_queue.wait_and_pop(future_buffer2);
assert(!future_buffer2.get());
}
return result;
@@ -534,9 +538,10 @@ TEST_CASE("Reading OSM XML 200") {
osmium::io::Header header = reader.header();
REQUIRE(header.get("generator") == "testdata");
osmium::memory::Buffer buffer = reader.read();
REQUIRE(0 == buffer.committed());
REQUIRE(! buffer);
REQUIRE_THROWS({
reader.read();
});
reader.close();
}