[mapnik-vector-tile] 01/06: Imported Upstream version 1.0.2+dfsg
Sebastiaan Couwenberg
sebastic at moszumanska.debian.org
Sat Mar 5 01:56:49 UTC 2016
This is an automated email from the git hooks/post-receive script.
sebastic pushed a commit to branch master
in repository mapnik-vector-tile.
commit f79c2f3bbc4959e83c1cce1cc81d6e76fbc38bee
Author: Bas Couwenberg <sebastic at xs4all.nl>
Date: Sat Mar 5 02:52:46 2016 +0100
Imported Upstream version 1.0.2+dfsg
---
CHANGELOG.md | 4 +
package.json | 2 +-
src/vector_tile_is_valid.hpp | 202 ++++++++++++++++++++++++++++++--
test/unit/is_valid/feature_is_valid.cpp | 2 +-
4 files changed, 195 insertions(+), 15 deletions(-)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 289e662..de9f4f7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
# Changelog
+## 1.0.2
+
+- Added more errors and checks to `vector_tile_is_valid.hpp`
+
## 1.0.1
- Updated to protozero v1.3.0
diff --git a/package.json b/package.json
index 25151c5..5021cc0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "mapnik-vector-tile",
- "version": "1.0.1",
+ "version": "1.0.2",
"description": "Mapnik Vector Tile API",
"main": "./package.json",
"repository" : {
diff --git a/src/vector_tile_is_valid.hpp b/src/vector_tile_is_valid.hpp
index 93dc82b..1ef6a82 100644
--- a/src/vector_tile_is_valid.hpp
+++ b/src/vector_tile_is_valid.hpp
@@ -20,16 +20,25 @@ enum validity_error : std::uint8_t
{
TILE_REPEATED_LAYER_NAMES = 0,
TILE_HAS_UNKNOWN_TAG,
+ TILE_HAS_DIFFERENT_VERSIONS,
LAYER_HAS_NO_NAME,
+ LAYER_HAS_MULTIPLE_NAME,
LAYER_HAS_NO_EXTENT,
+ LAYER_HAS_MULTIPLE_EXTENT,
+ LAYER_HAS_MULTIPLE_VERSION,
LAYER_HAS_NO_FEATURES,
LAYER_HAS_INVALID_VERSION,
+ LAYER_HAS_RASTER_AND_VECTOR,
LAYER_HAS_UNKNOWN_TAG,
VALUE_MULTIPLE_VALUES,
VALUE_NO_VALUE,
VALUE_HAS_UNKNOWN_TAG,
FEATURE_IS_EMPTY,
+ FEATURE_MULTIPLE_ID,
+ FEATURE_MULTIPLE_TAGS,
FEATURE_MULTIPLE_GEOM,
+ FEATURE_MULTIPLE_RASTER,
+ FEATURE_RASTER_AND_GEOM,
FEATURE_NO_GEOM_TYPE,
FEATURE_HAS_INVALID_GEOM_TYPE,
FEATURE_HAS_UNKNOWN_TAG,
@@ -44,14 +53,24 @@ inline std::string validity_error_to_string(validity_error err)
return "Vector Tile message has two or more layers with the same name";
case TILE_HAS_UNKNOWN_TAG:
return "Vector Tile message has an unknown tag";
+ case TILE_HAS_DIFFERENT_VERSIONS:
+ return "Vector Tile message has layers with different versions";
case LAYER_HAS_NO_NAME:
return "Vector Tile Layer message has no name";
+ case LAYER_HAS_MULTIPLE_NAME:
+ return "Vector Tile Layer message has multiple name tags";
case LAYER_HAS_NO_EXTENT:
return "Vector Tile Layer message has no extent";
+ case LAYER_HAS_MULTIPLE_EXTENT:
+ return "Vector Tile Layer message has multiple extent tags";
case LAYER_HAS_NO_FEATURES:
return "Vector Tile Layer message has no features";
+ case LAYER_HAS_MULTIPLE_VERSION:
+ return "Vector Tile Layer message has multiple version tags";
case LAYER_HAS_INVALID_VERSION:
return "Vector Tile Layer message has an invalid version";
+ case LAYER_HAS_RASTER_AND_VECTOR:
+ return "Vector Tile Layer contains raster and vector features";
case LAYER_HAS_UNKNOWN_TAG:
return "Vector Tile Layer message has an unknown tag";
case VALUE_MULTIPLE_VALUES:
@@ -62,8 +81,16 @@ inline std::string validity_error_to_string(validity_error err)
return "Vector Tile Value message has an unknown tag";
case FEATURE_IS_EMPTY:
return "Vector Tile Feature message has no geometry";
+ case FEATURE_MULTIPLE_ID:
+ return "Vector Tile Feature message has multiple ids";
+ case FEATURE_MULTIPLE_TAGS:
+ return "Vector Tile Feature message has multiple repeated tags";
case FEATURE_MULTIPLE_GEOM:
return "Vector Tile Feature message has multiple geometries";
+ case FEATURE_MULTIPLE_RASTER:
+ return "Vector Tile Feature message has multiple rasters";
+ case FEATURE_RASTER_AND_GEOM:
+ return "Vector Tile Feature message has raster and geometry types";
case FEATURE_NO_GEOM_TYPE:
return "Vector Tile Feature message is missing a geometry type";
case FEATURE_HAS_INVALID_GEOM_TYPE:
@@ -92,25 +119,59 @@ inline void validity_error_to_string(std::set<validity_error> & errors, std::str
out.append(err.str());
}
-inline void feature_is_valid(protozero::pbf_reader & feature_msg, std::set<validity_error> & errors)
+inline void feature_is_valid(protozero::pbf_reader & feature_msg,
+ std::set<validity_error> & errors,
+ std::uint64_t & point_feature_count,
+ std::uint64_t & line_feature_count,
+ std::uint64_t & polygon_feature_count,
+ std::uint64_t & unknown_feature_count,
+ std::uint64_t & raster_feature_count)
{
bool has_geom = false;
bool has_raster = false;
bool has_type = false;
+ bool has_id = false;
+ bool has_tags = false;
while (feature_msg.next())
{
switch (feature_msg.tag())
{
case Feature_Encoding::ID: // id
+ if (has_id)
+ {
+ errors.insert(FEATURE_MULTIPLE_ID);
+ }
+ has_id = true;
feature_msg.skip();
break;
case Feature_Encoding::TAGS: // tags
+ if (has_tags)
+ {
+ errors.insert(FEATURE_MULTIPLE_TAGS);
+ }
+ has_tags = true;
feature_msg.get_packed_uint32();
break;
case Feature_Encoding::TYPE: // geom type
{
std::int32_t type = feature_msg.get_enum();
- if (type <= 0 || type > 3)
+ if (type == Geometry_Type::POINT)
+ {
+ ++point_feature_count;
+ }
+ else if (type == Geometry_Type::LINESTRING)
+ {
+ ++line_feature_count;
+ }
+ else if (type == Geometry_Type::POLYGON)
+ {
+ ++polygon_feature_count;
+ }
+ else if (type == Geometry_Type::UNKNOWN)
+ {
+ ++unknown_feature_count;
+ }
+ else
{
errors.insert(FEATURE_HAS_INVALID_GEOM_TYPE);
}
@@ -118,19 +179,28 @@ inline void feature_is_valid(protozero::pbf_reader & feature_msg, std::set<valid
}
break;
case Feature_Encoding::GEOMETRY: // geometry
- if (has_geom || has_raster)
+ if (has_geom)
{
errors.insert(FEATURE_MULTIPLE_GEOM);
}
+ if (has_raster)
+ {
+ errors.insert(FEATURE_RASTER_AND_GEOM);
+ }
has_geom = true;
feature_msg.get_packed_uint32();
break;
case Feature_Encoding::RASTER: // raster
- if (has_geom || has_raster)
+ if (has_geom)
{
- errors.insert(FEATURE_MULTIPLE_GEOM);
+ errors.insert(FEATURE_RASTER_AND_GEOM);
+ }
+ if (has_raster)
+ {
+ errors.insert(FEATURE_MULTIPLE_RASTER);
}
has_raster = true;
+ ++raster_feature_count;
feature_msg.get_data();
break;
default:
@@ -149,6 +219,23 @@ inline void feature_is_valid(protozero::pbf_reader & feature_msg, std::set<valid
}
}
+inline void feature_is_valid(protozero::pbf_reader & feature_msg,
+ std::set<validity_error> & errors)
+{
+ std::uint64_t point_feature_count = 0;
+ std::uint64_t line_feature_count = 0;
+ std::uint64_t polygon_feature_count = 0;
+ std::uint64_t unknown_feature_count = 0;
+ std::uint64_t raster_feature_count = 0;
+ return feature_is_valid(feature_msg,
+ errors,
+ point_feature_count,
+ line_feature_count,
+ polygon_feature_count,
+ unknown_feature_count,
+ raster_feature_count);
+}
+
inline void value_is_valid(protozero::pbf_reader & value_msg, std::set<validity_error> & errors)
{
bool has_value = false;
@@ -185,11 +272,17 @@ inline void value_is_valid(protozero::pbf_reader & value_msg, std::set<validity_
inline void layer_is_valid(protozero::pbf_reader & layer_msg,
std::set<validity_error> & errors,
std::string & layer_name,
- std::uint32_t & version)
+ std::uint32_t & version,
+ std::uint64_t & point_feature_count,
+ std::uint64_t & line_feature_count,
+ std::uint64_t & polygon_feature_count,
+ std::uint64_t & unknown_feature_count,
+ std::uint64_t & raster_feature_count)
{
bool contains_a_feature = false;
bool contains_a_name = false;
bool contains_an_extent = false;
+ bool contains_a_version = false;
try
{
while (layer_msg.next())
@@ -197,6 +290,10 @@ inline void layer_is_valid(protozero::pbf_reader & layer_msg,
switch (layer_msg.tag())
{
case Layer_Encoding::NAME: // name
+ if (contains_a_name)
+ {
+ errors.insert(LAYER_HAS_MULTIPLE_NAME);
+ }
contains_a_name = true;
layer_name = layer_msg.get_string();
break;
@@ -204,7 +301,13 @@ inline void layer_is_valid(protozero::pbf_reader & layer_msg,
{
contains_a_feature = true;
protozero::pbf_reader feature_msg = layer_msg.get_message();
- feature_is_valid(feature_msg, errors);
+ feature_is_valid(feature_msg,
+ errors,
+ point_feature_count,
+ line_feature_count,
+ polygon_feature_count,
+ unknown_feature_count,
+ raster_feature_count);
}
break;
case Layer_Encoding::KEYS: // keys
@@ -217,10 +320,19 @@ inline void layer_is_valid(protozero::pbf_reader & layer_msg,
}
break;
case Layer_Encoding::EXTENT: // extent
+ if (contains_an_extent)
+ {
+ errors.insert(LAYER_HAS_MULTIPLE_EXTENT);
+ }
contains_an_extent = true;
layer_msg.skip();
break;
case Layer_Encoding::VERSION:
+ if (contains_a_version)
+ {
+ errors.insert(LAYER_HAS_MULTIPLE_VERSION);
+ }
+ contains_a_version = true;
version = layer_msg.get_uint32();
break;
default:
@@ -252,13 +364,43 @@ inline void layer_is_valid(protozero::pbf_reader & layer_msg,
}
}
+inline void layer_is_valid(protozero::pbf_reader & layer_msg,
+ std::set<validity_error> & errors,
+ std::string & layer_name,
+ std::uint32_t & version)
+{
+
+ std::uint64_t point_feature_count = 0;
+ std::uint64_t line_feature_count = 0;
+ std::uint64_t polygon_feature_count = 0;
+ std::uint64_t unknown_feature_count = 0;
+ std::uint64_t raster_feature_count = 0;
+ return layer_is_valid(layer_msg,
+ errors,
+ layer_name,
+ version,
+ point_feature_count,
+ line_feature_count,
+ polygon_feature_count,
+ unknown_feature_count,
+ raster_feature_count);
+}
+
// Check some common things that could be wrong with a tile
// does not check all items in line with the v2 spec. For
// example does does not check validity of geometry. It also does not
// verify that all feature attributes are valid.
-inline void tile_is_valid(protozero::pbf_reader & tile_msg, std::set<validity_error> & errors)
+inline void tile_is_valid(protozero::pbf_reader & tile_msg,
+ std::set<validity_error> & errors,
+ std::uint32_t & version,
+ std::uint64_t & point_feature_count,
+ std::uint64_t & line_feature_count,
+ std::uint64_t & polygon_feature_count,
+ std::uint64_t & unknown_feature_count,
+ std::uint64_t & raster_feature_count)
{
std::set<std::string> layer_names_set;
+ bool first_layer = true;
try
{
while (tile_msg.next())
@@ -269,13 +411,28 @@ inline void tile_is_valid(protozero::pbf_reader & tile_msg, std::set<validity_er
{
protozero::pbf_reader layer_msg = tile_msg.get_message();
std::string layer_name;
- std::uint32_t version = 1;
- layer_is_valid(layer_msg, errors, layer_name, version);
- auto p = layer_names_set.insert(layer_name);
- if (!p.second)
+ std::uint32_t layer_version = 1;
+ layer_is_valid(layer_msg, errors, layer_name, layer_version);
+ if (!layer_name.empty())
{
- errors.insert(TILE_REPEATED_LAYER_NAMES);
+ auto p = layer_names_set.insert(layer_name);
+ if (!p.second)
+ {
+ errors.insert(TILE_REPEATED_LAYER_NAMES);
+ }
}
+ if (first_layer)
+ {
+ version = layer_version;
+ }
+ else
+ {
+ if (version != layer_version)
+ {
+ errors.insert(TILE_HAS_DIFFERENT_VERSIONS);
+ }
+ }
+ first_layer = false;
}
break;
default:
@@ -291,6 +448,25 @@ inline void tile_is_valid(protozero::pbf_reader & tile_msg, std::set<validity_er
}
}
+inline void tile_is_valid(protozero::pbf_reader & tile_msg,
+ std::set<validity_error> & errors)
+{
+ std::uint32_t version = 1;
+ std::uint64_t point_feature_count = 0;
+ std::uint64_t line_feature_count = 0;
+ std::uint64_t polygon_feature_count = 0;
+ std::uint64_t unknown_feature_count = 0;
+ std::uint64_t raster_feature_count = 0;
+ return tile_is_valid(tile_msg,
+ errors,
+ version,
+ point_feature_count,
+ line_feature_count,
+ polygon_feature_count,
+ unknown_feature_count,
+ raster_feature_count);
+}
+
inline void tile_is_valid(std::string const& tile, std::set<validity_error> & errors)
{
protozero::pbf_reader tile_msg(tile);
diff --git a/test/unit/is_valid/feature_is_valid.cpp b/test/unit/is_valid/feature_is_valid.cpp
index b3e9ce6..e810ae6 100644
--- a/test/unit/is_valid/feature_is_valid.cpp
+++ b/test/unit/is_valid/feature_is_valid.cpp
@@ -114,7 +114,7 @@ TEST_CASE( "invalid feature with geometry and raster" )
feature_is_valid(pbf_feature, errs);
CHECK(errs.empty() == false);
- CHECK(errs.count(mapnik::vector_tile_impl::validity_error::FEATURE_MULTIPLE_GEOM) == 1);
+ CHECK(errs.count(mapnik::vector_tile_impl::validity_error::FEATURE_RASTER_AND_GEOM) == 1);
}
TEST_CASE( "invalid unknown tag in feature" )
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-grass/mapnik-vector-tile.git
More information about the Pkg-grass-devel
mailing list