void validate_node_layer(protozero::pbf_reader &layer_message) { using namespace osrm; auto number_of_nodes_found = 0u; const auto check_osmnode_feature = [](protozero::pbf_reader feature_message) { feature_message.next(); // advance parser to first entry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG); BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT); feature_message.next(); // advance to next entry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG); feature_message.get_uint64(); // id feature_message.next(); // advance to next entry // Note - on this layer, there should be no feature attributes, the next thing // we get should be the geometry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_GEOMETRIES_TAG); auto geometry_iter_pair = feature_message.get_packed_uint32(); BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1); }; while (layer_message.next()) { switch (layer_message.tag()) { case util::vector_tile::VERSION_TAG: BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2); break; case util::vector_tile::NAME_TAG: BOOST_CHECK_EQUAL(layer_message.get_string(), "osmnodes"); break; case util::vector_tile::EXTENT_TAG: BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT); break; case util::vector_tile::FEATURE_TAG: check_osmnode_feature(layer_message.get_message()); number_of_nodes_found++; break; case util::vector_tile::KEY_TAG: BOOST_CHECK(false); // There should be no properties on node features break; case util::vector_tile::VARIANT_TAG: BOOST_CHECK(false); // There should be no properties on node features break; default: BOOST_CHECK(false); // invalid tag break; } } BOOST_CHECK_EQUAL(number_of_nodes_found, 1791); }
inline void check_empty(protozero::pbf_reader message) { while (message.next()) { switch (message.tag()) { case 1: { REQUIRE(!message.get_message().next()); break; } case 2: { REQUIRE(77 == message.get_int32()); break; } default: { REQUIRE(false); // should never be here break; } } } }
} return ""; } } // anon namespace TEST_CASE("reading vector tiles") { const std::string buffer = load_data("vector_tile/data.vector"); protozero::pbf_reader item{buffer}; std::vector<std::string> layer_names; SECTION("iterate over message using next()") { while (item.next()) { if (item.tag() == 3) { // repeated message Layer protozero::pbf_reader layer{item.get_message()}; while (layer.next()) { switch (layer.tag()) { case 1: // required string name layer_names.push_back(layer.get_string()); break; default: layer.skip(); } } } else { item.skip(); } } REQUIRE(layer_names == expected_layer_names);
void validate_feature_layer(protozero::pbf_reader &layer_message) { using namespace osrm; const auto check_feature = [](protozero::pbf_reader feature_message) { feature_message.next(); // advance parser to first entry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG); BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_LINE); feature_message.next(); // advance to next entry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG); feature_message.get_uint64(); // id feature_message.next(); // advance to next entry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG); // properties auto property_iter_pair = feature_message.get_packed_uint32(); auto value_begin = property_iter_pair.begin(); auto value_end = property_iter_pair.end(); BOOST_CHECK_EQUAL(std::distance(value_begin, value_end), 14); auto iter = value_begin; BOOST_CHECK_EQUAL(*iter++, 0); // speed key BOOST_CHECK_LT(*iter++, 128); // speed value BOOST_CHECK_EQUAL(*iter++, 1); // component key // component value BOOST_CHECK_GE(*iter, 128); BOOST_CHECK_LE(*iter, 129); iter++; BOOST_CHECK_EQUAL(*iter++, 2); // data source key *iter++; // skip value check, can be valud uint32 BOOST_CHECK_EQUAL(*iter++, 3); // weight key BOOST_CHECK_GT(*iter++, 130); // weight value BOOST_CHECK_EQUAL(*iter++, 4); // duration key BOOST_CHECK_GT(*iter++, 130); // duration value // name BOOST_CHECK_EQUAL(*iter++, 5); BOOST_CHECK_GT(*iter++, 130); // rate BOOST_CHECK_EQUAL(*iter++, 6); BOOST_CHECK_GT(*iter++, 130); BOOST_CHECK(iter == value_end); // geometry feature_message.next(); auto geometry_iter_pair = feature_message.get_packed_uint32(); BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1); }; auto number_of_speed_keys = 0u; auto number_of_speed_values = 0u; while (layer_message.next()) { switch (layer_message.tag()) { case util::vector_tile::VERSION_TAG: BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2); break; case util::vector_tile::NAME_TAG: BOOST_CHECK_EQUAL(layer_message.get_string(), "speeds"); break; case util::vector_tile::EXTENT_TAG: BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT); break; case util::vector_tile::FEATURE_TAG: check_feature(layer_message.get_message()); break; case util::vector_tile::KEY_TAG: layer_message.get_string(); number_of_speed_keys++; break; case util::vector_tile::VARIANT_TAG: validate_value(layer_message.get_message()); number_of_speed_values++; break; default: BOOST_CHECK(false); // invalid tag break; } } BOOST_CHECK_EQUAL(number_of_speed_keys, 7); BOOST_CHECK_GT(number_of_speed_values, 128); // speed value resolution }
void validate_turn_layer(protozero::pbf_reader &layer_message) { using namespace osrm; const auto check_turn_feature = [](protozero::pbf_reader feature_message) { feature_message.next(); // advance parser to first entry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::GEOMETRY_TAG); BOOST_CHECK_EQUAL(feature_message.get_enum(), util::vector_tile::GEOMETRY_TYPE_POINT); feature_message.next(); // advance to next entry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::ID_TAG); feature_message.get_uint64(); // id feature_message.next(); // advance to next entry BOOST_CHECK_EQUAL(feature_message.tag(), util::vector_tile::FEATURE_ATTRIBUTES_TAG); // properties auto feature_iter_pair = feature_message.get_packed_uint32(); BOOST_CHECK_EQUAL(std::distance(feature_iter_pair.begin(), feature_iter_pair.end()), 12); auto iter = feature_iter_pair.begin(); BOOST_CHECK_EQUAL(*iter++, 0); // bearing_in key *iter++; BOOST_CHECK_EQUAL(*iter++, 1); // turn_angle key *iter++; BOOST_CHECK_EQUAL(*iter++, 2); // turn cost (duration) key *iter++; // skip value check, can be valud uint32 BOOST_CHECK_EQUAL(*iter++, 3); // turn weight key *iter++; // skip value check, can be valud uint32 BOOST_CHECK_EQUAL(*iter++, 4); // turn type key *iter++; // skip value check, can be valud uint32 BOOST_CHECK_EQUAL(*iter++, 5); // turn modifier *iter++; // skip value check, can be valud uint32 BOOST_CHECK(iter == feature_iter_pair.end()); // geometry feature_message.next(); auto geometry_iter_pair = feature_message.get_packed_uint32(); BOOST_CHECK_GT(std::distance(geometry_iter_pair.begin(), geometry_iter_pair.end()), 1); }; auto number_of_turn_keys = 0u; auto number_of_turns_found = 0u; while (layer_message.next()) { switch (layer_message.tag()) { case util::vector_tile::VERSION_TAG: BOOST_CHECK_EQUAL(layer_message.get_uint32(), 2); break; case util::vector_tile::NAME_TAG: BOOST_CHECK_EQUAL(layer_message.get_string(), "turns"); break; case util::vector_tile::EXTENT_TAG: BOOST_CHECK_EQUAL(layer_message.get_uint32(), util::vector_tile::EXTENT); break; case util::vector_tile::FEATURE_TAG: check_turn_feature(layer_message.get_message()); number_of_turns_found++; break; case util::vector_tile::KEY_TAG: layer_message.get_string(); number_of_turn_keys++; break; case util::vector_tile::VARIANT_TAG: validate_value(layer_message.get_message()); break; default: BOOST_CHECK(false); // invalid tag break; } } BOOST_CHECK_EQUAL(number_of_turn_keys, 6); BOOST_CHECK(number_of_turns_found > 700); }
REQUIRE(1 == tile.layers_size()); vector_tile::Tile_Layer const& layer = tile.layers(0); CHECK(std::string("layer") == layer.name()); REQUIRE(1 == layer.features_size()); vector_tile::Tile_Feature const& f = layer.features(0); unsigned z = 0; unsigned x = 0; unsigned y = 0; double resolution = mapnik::EARTH_CIRCUMFERENCE/(1 << z); double tile_x = -0.5 * mapnik::EARTH_CIRCUMFERENCE + x * resolution; double tile_y = 0.5 * mapnik::EARTH_CIRCUMFERENCE - y * resolution; double scale = static_cast<double>(layer.extent())/resolution; protozero::pbf_reader layer_reader; out_tile.layer_reader(0, layer_reader); REQUIRE(layer_reader.next(mapnik::vector_tile_impl::Layer_Encoding::FEATURES)); protozero::pbf_reader feature_reader = layer_reader.get_message(); int32_t geometry_type = mapnik::vector_tile_impl::Geometry_Type::UNKNOWN; mapnik::vector_tile_impl::GeometryPBF::pbf_itr geom_itr; while (feature_reader.next()) { if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::GEOMETRY) { geom_itr = feature_reader.get_packed_uint32(); } else if (feature_reader.tag() == mapnik::vector_tile_impl::Feature_Encoding::TYPE) { geometry_type = feature_reader.get_enum(); } else { feature_reader.skip();
CHECK(tile2.ParseFromString(buffer)); std::string key(""); CHECK(false == mapnik::vector_tile_impl::is_solid_extent(tile2,key)); CHECK("" == key); CHECK(false == mapnik::vector_tile_impl::is_solid_extent(buffer,key)); CHECK("" == key); CHECK(1 == tile2.layers_size()); vector_tile::Tile_Layer const& layer2 = tile2.layers(0); CHECK(std::string("layer") == layer2.name()); CHECK(1 == layer2.features_size()); mapnik::layer lyr2("layer",map.srs()); protozero::pbf_reader pbf_tile(buffer.c_str(), buffer.size()); pbf_tile.next(); protozero::pbf_reader layer3 = pbf_tile.get_message(); std::shared_ptr<mapnik::vector_tile_impl::tile_datasource_pbf> ds = std::make_shared< mapnik::vector_tile_impl::tile_datasource_pbf>( layer3,0,0,0,map2.width()); CHECK(ds->get_name() == "layer"); ds->set_envelope(bbox); CHECK( ds->type() == mapnik::datasource::Vector ); CHECK( ds->get_geometry_type() == mapnik::datasource_geometry_t::Collection ); mapnik::layer_descriptor lay_desc = ds->get_descriptor(); std::vector<std::string> expected_names; expected_names.push_back("bool"); expected_names.push_back("boolf"); expected_names.push_back("double"); expected_names.push_back("float"); expected_names.push_back("int");