def test_request_z7(self):
zoom, x, y = 7, 20, 49
req = renderer.Request(x, y, zoom)
assert req.zoom == zoom and req.x == x and req.y == y
assert req.size == 256
assert abs(req.get_width() - 313086.0700000003) < 1
assert abs(req.get_height() - 313085.8099999996) < 1
assert req.extent.intersects(-13469658, 4579425) # -121,38
assert not req.extent.intersects(-14471533.80, 5621521.49)
def test_adding_duplicate_points(self):
""" Test that points are deduplicated """
req = renderer.Request(0, 0, 0)
vtile = renderer.VectorTile(req)
layer = vtile.add_layer(name="points")
vtile.add_point(layer, 0, 0, {})
vtile.add_point(layer, 0, 0, {})
self.assertEqual(len(layer.features), 1)
j_obj = vtile.to_geojson()
self.assertEqual(len(j_obj['features']), 1)
def test_layer_creation(self):
""" Test creating an empty tile and an empty layer """
req = renderer.Request(0, 0, 0)
vtile = renderer.VectorTile(req)
assert isinstance(vtile.tile, vector_tile_pb2.Tile)
self.assertEqual(len(vtile.tile.layers), 0)
layer = vtile.add_layer(name="points")
assert layer is not None and isinstance(layer,
vector_tile_pb2.Tile.Layer)
self.assertEqual(len(vtile.tile.layers), 1)
self.assertEqual(vtile.tile.layers[0], layer)
self.assertEqual(len(layer.features), 0)
def test_vtile_z0(self):
""" Test adding points at zoom 0 """
req = renderer.Request(0, 0, 0)
vtile = renderer.VectorTile(req)
layer = vtile.add_layer(name="points")
x, y = -8526703.378081053, 4740318.745473632
vtile.add_point(layer, x, y, {})
j_obj = vtile.to_geojson()
feature = j_obj['features'][0]
coords = feature['geometry']['coordinates']
self.assertAlmostEqual(coords[0], x, -4)
self.assertAlmostEqual(coords[1], y, -4)
def test_ctrans_z7(self):
""" Test render.CoordTransform """
zoom, x, y = 7, 20, 49
req = renderer.Request(x, y, zoom)
transform = renderer.CoordTransform(req)
testX, testY = -13469658, 4579425
projectedX, projectedY = transform.forward(testX, testY)
assert projectedX > 0 and projectedX < 256
assert projectedY > 0 and projectedY < 256
reversedX, reversedY = transform.backward(projectedX, projectedY)
assert abs(testX - reversedX) < 1
assert abs(testY - reversedY) < 1
def test_ctrans_z0(self):
req = renderer.Request(0, 0, 0)
x, y = renderer.lonlat2merc(-180, -85)
ctrans = renderer.CoordTransform(req)
px, py = ctrans.forward(x, y)
self.assertAlmostEqual(px, 0.0)
self.assertAlmostEqual(py, 255.5806938147701)
px2, py2 = ctrans.forward(-20037508.34, -20037508.34)
self.assertAlmostEqual(px2, 0.0)
self.assertAlmostEqual(py2, 256.0)
px3, py3 = ctrans.forward(-20037508.34 / 2, -20037508.34 / 2)
self.assertAlmostEqual(px2, 0.0)
self.assertAlmostEqual(py2, 256.0)
def test_vtile_z22_higher_precision(self):
""" Test adding points at zoom 22 with larger than standard path multiplier """
merc = renderer.SphericalMercator()
x, y = -8526703.378081053, 4740318.745473632
xyz_bounds = merc.xyz([x, y, x, y], 22)
req = renderer.Request(xyz_bounds[0], xyz_bounds[1], 22)
vtile = renderer.VectorTile(req, path_multiplier=512)
layer = vtile.add_layer(name="points")
vtile.add_point(layer, x, y, {})
j_obj = vtile.to_geojson()
feature = j_obj['features'][0]
coords = feature['geometry']['coordinates']
self.assertAlmostEqual(coords[0], x, 4)
self.assertAlmostEqual(coords[1], y, 4)
def test_vtile_z22(self):
""" Test adding points at zoom 22 """
merc = renderer.SphericalMercator()
x, y = -8526703.378081053, 4740318.745473632
xyz_bounds = merc.xyz([x, y, x, y], 22)
req = renderer.Request(xyz_bounds[0], xyz_bounds[1], 22)
vtile = renderer.VectorTile(req)
layer = vtile.add_layer(name="points")
vtile.add_point(layer, x, y, {})
j_obj = vtile.to_geojson()
feature = j_obj['features'][0]
coords = feature['geometry']['coordinates']
self.assertAlmostEqual(coords[0], x, 2)
self.assertAlmostEqual(coords[1], y, 1)
def test_simple_tile_z0(self):
""" Test creating a tile, adding a single layer and a single point """
req = renderer.Request(0, 0, 0)
vtile = renderer.VectorTile(req)
#Test creating a layer
layerName = "points"
layer = vtile.add_layer(name=layerName)
#test adding a point feature
lat, lng = 38, -121
attr = {"hello": "world"}
x, y = renderer.lonlat2merc(lng, lat)
assert vtile.add_point(layer, x, y, attr)
assert len(layer.features) == 1
feature = layer.features[0]
key_id = feature.tags[0]
value_id = feature.tags[1]
key = str(layer.keys[key_id])
assert key == "hello"
value = layer.values[value_id]
assert value.HasField('string_value')
assert value.string_value == "world"
#dump the layer to GeoJSON and make sure the output matches the input
j_obj = vtile.to_geojson(layer_names=True, lonlat=True)
assert isinstance(j_obj, dict)
self.assertEqual(j_obj["type"], "FeatureCollection")
self.assertEqual(len(j_obj["features"]), 1)
self.assertEqual(j_obj["features"][0]["geometry"]["type"], "Point")
self.assertEqual(len(j_obj["features"][0]["geometry"]["coordinates"]),
2)
self.assertAlmostEqual(
j_obj["features"][0]["geometry"]["coordinates"][0], lng, 0)
self.assertAlmostEqual(
j_obj["features"][0]["geometry"]["coordinates"][1], lat, 0)
self.assertEqual(j_obj["features"][0]["properties"]["layer"],
layerName)
self.assertEqual(j_obj["features"][0]["properties"]["hello"], "world")
#now dump tile to protocol buffer message
pbf = vtile.to_message()
assert len(pbf) > 0
tile = vector_tile_pb2.Tile()
tile.ParseFromString(pbf)
vtile2 = renderer.VectorTile(req, tile)
j_obj_deserialized = vtile2.to_geojson(layer_names=True, lonlat=True)
self.assertDictEqual(j_obj, j_obj_deserialized)
def test_key_value_deduplication(self):
""" Test that keys and values are properly deduplicated """
req = renderer.Request(0, 0, 0)
vtile = renderer.VectorTile(req)
layer = vtile.add_layer(name="points")
assert len(layer.keys) == 0 and len(layer.values) == 0
width = req.get_width()
height = req.get_height()
attr = {"hello": "world"}
#add a point, it should add 1 key and 1 value
vtile.add_point(layer, width * .1, height * .1, attr)
assert len(layer.keys) == 1 and len(layer.values) == 1
#add another feature with the same key and value
vtile.add_point(layer, width * .2, height * .2, attr)
assert len(layer.keys) == 1 and len(layer.values) == 1
#add another feature with existing key and new value
vtile.add_point(layer, width * .4, height * .3, {"hello": "mars"})
assert len(layer.keys) == 1 and len(layer.values) == 2
#add another feature with an existing value and a new key
vtile.add_point(layer, width * .5, height * .5, {"goodbye": "world"})
assert len(layer.keys) == 2 and len(layer.values) == 2
def test_attribute_types(self):
""" Test that all attribute types are handled correctly """
req = renderer.Request(0, 0, 0)
vtile = renderer.VectorTile(req)
layer = vtile.add_layer(name="points")
attr = {
"name": "DC",
"integer": 10,
"bigint": sys.maxsize,
"nbigint": -1 * sys.maxsize,
"float": 1.5,
"bigfloat": float(sys.maxsize),
"unistr": u"élan",
"bool": True,
"bool2": False
}
vtile.add_point(layer, 0, 0, attr)
j_obj = vtile.to_geojson()
self.assertEqual(j_obj['type'], "FeatureCollection")
self.assertEqual(len(j_obj['features']), 1)
feature = j_obj['features'][0]
self.assertDictEqual(feature['properties'], attr)
zoom = options.z
x = options.x
y = options.y
else:
stderr("Error: no tile address, use -x -y and -z, or -t z/x/y")
sys.exit(0)
filename = args[0]
if options.verbose:
stderr("opening %s as tile %d/%d/%d" % (filename, zoom, x, y))
with open(filename, "rb") as f:
tile = vector_tile_pb2.Tile()
decoded = f.read()
tile.ParseFromString(decoded)
req = renderer.Request(x, y, zoom)
vtile = renderer.VectorTile(req, tile)
vtile.layer = tile.Layer
if options.layer:
for layer in tile.layers:
if layer.name == options.layer:
print(
vtile.to_geojson(layer=layer,
lonlat=True,
layer_names=True))
break
else:
print(
json.dumps(vtile.to_geojson(lonlat=True, layer_names=True),
indent=4))
def test_request_z0(self):
zoom, x, y = 0, 0, 0
req = renderer.Request(x, y, zoom)
self.assertAlmostEqual(req.get_width(), 40075016.68557849)
self.assertAlmostEqual(req.get_height(), 40075016.68557849)
