def _make_layer_info(layer_data, process_yaml_cfg):
from tilequeue.query.common import LayerInfo, ShapeType
layers = {}
functions = _parse_yaml_functions(process_yaml_cfg)
for layer_datum in layer_data:
name = layer_datum['name']
min_zoom_fn, props_fn = functions[name]
shape_types = ShapeType.parse_set(layer_datum['geometry_types'])
layer_info = LayerInfo(min_zoom_fn, props_fn, shape_types)
layers[name] = layer_info
return layers
def _test(self, input_layer_names, expected_layer_names):
from shapely.geometry import Point
from tilequeue.query.common import LayerInfo
from tilequeue.query.fixture import make_fixture_data_fetcher
from tilequeue.tile import coord_to_mercator_bounds
from tilequeue.tile import mercator_point_to_coord
def min_zoom_fn(shape, props, fid, meta):
return 0
def props_fn(shape, props, fid, meta):
return {}
shape = Point(0, 0)
props = {'name': 'Foo', 'name:en': 'Bar'}
rows = [
(1, shape, props),
]
layers = {}
for name in input_layer_names:
layers[name] = LayerInfo(min_zoom_fn, props_fn)
fetch = make_fixture_data_fetcher(layers, rows)
feature_coord = mercator_point_to_coord(16, shape.x, shape.y)
read_rows = fetch(16, coord_to_mercator_bounds(feature_coord))
self.assertEqual(1, len(read_rows))
all_layer_names = set(expected_layer_names) | set(input_layer_names)
for layer_name in all_layer_names:
properties_name = '__%s_properties__' % layer_name
self.assertTrue(properties_name in read_rows[0])
for key in props.keys():
actual_name = read_rows[0][properties_name].get(key)
if layer_name in expected_layer_names:
expected_name = props.get(key)
self.assertEquals(
expected_name,
actual_name,
msg=('expected=%r, actual=%r for key=%r' %
(expected_name, actual_name, key)))
else:
# check the name doesn't appear anywhere else
self.assertEquals(
None,
actual_name,
msg=('got actual=%r for key=%r, expected no value' %
(actual_name, key)))
def _make(self,
rows,
min_zoom_fn,
props_fn,
relations=[],
layer_name='testlayer',
label_placement_layers={}):
from tilequeue.query.common import LayerInfo
from tilequeue.query.fixture import make_fixture_data_fetcher
layers = {layer_name: LayerInfo(min_zoom_fn, props_fn)}
return make_fixture_data_fetcher(
layers,
rows,
label_placement_layers=label_placement_layers,
relations=relations)
def _fetch_data(self, shape_fn, source_table):
from tilequeue.query.common import LayerInfo
from tilequeue.query.rawr import make_rawr_data_fetcher
from tilequeue.tile import coord_to_mercator_bounds
from ModestMaps.Core import Coordinate
top_zoom = 10
max_zoom = top_zoom + 6
def min_zoom_fn(shape, props, fid, meta):
return top_zoom
def props_fn(shape, props, fid, meta):
return {'kind': 'country'}
z, x, y = (max_zoom, 0, 0)
tile = Coordinate(zoom=z, column=x, row=y)
top_tile = tile.zoomTo(top_zoom).container()
bounds = coord_to_mercator_bounds(tile)
shape = shape_fn(bounds)
props = {
'name': 'Foo',
'admin_level': '2',
'boundary': 'administrative',
}
source = 'test'
tables = TestGetTable({
source_table: [
(1, shape.wkb, props),
],
}, source)
layers = {
'boundaries': LayerInfo(min_zoom_fn, props_fn),
}
storage = ConstantStorage(tables)
fetch = make_rawr_data_fetcher(top_zoom, max_zoom, storage, layers,
[dict(type="osm")])
for fetcher, _ in fetch.fetch_tiles(_wrap(top_tile)):
read_rows = fetcher(tile.zoom, coord_to_mercator_bounds(tile))
return read_rows
def _make(self,
min_zoom_fn,
props_fn,
tables,
tile_pyramid,
layer_name='testlayer',
label_placement_layers={},
min_z=10,
max_z=16):
from tilequeue.query.common import LayerInfo
from tilequeue.query.rawr import make_rawr_data_fetcher
layers = {layer_name: LayerInfo(min_zoom_fn, props_fn)}
storage = ConstantStorage(tables)
indexes_cfg = [dict(type="osm")]
return make_rawr_data_fetcher(
min_z,
max_z,
storage,
layers,
indexes_cfg,
label_placement_layers=label_placement_layers)
def _test(self, input_layer_names, expected_layer_names):
from shapely.geometry import Point
from tilequeue.query.common import LayerInfo
from tilequeue.query.rawr import make_rawr_data_fetcher
from tilequeue.tile import coord_to_mercator_bounds
from tilequeue.tile import mercator_point_to_coord
top_zoom = 10
max_zoom = top_zoom + 6
def min_zoom_fn(shape, props, fid, meta):
return top_zoom
def props_fn(shape, props, fid, meta):
return {}
shape = Point(0, 0)
props = {'name': 'Foo', 'name:en': 'Bar'}
source = 'test'
tables = TestGetTable({
'planet_osm_point': [
(1, shape.wkb, props),
],
}, source)
tile = mercator_point_to_coord(max_zoom, shape.x, shape.y)
top_tile = tile.zoomTo(top_zoom).container()
layers = {}
for name in input_layer_names:
layers[name] = LayerInfo(min_zoom_fn, props_fn)
storage = ConstantStorage(tables)
fetch = make_rawr_data_fetcher(top_zoom, max_zoom, storage, layers,
[dict(type="osm")])
for fetcher, _ in fetch.fetch_tiles(_wrap(top_tile)):
read_rows = fetcher(tile.zoom, coord_to_mercator_bounds(tile))
# the RAWR query goes over features multiple times because of the
# indexing, so we can't rely on all the properties for one feature to
# be all together in the same place. this loops over all the features,
# checking that there's only really one of them and gathering together
# all the __%s_properties__ from all the rows for further testing.
all_props = {}
for row in read_rows:
self.assertEquals(1, row['__id__'])
self.assertEquals(shape.wkb, row['__geometry__'])
for key, val in row.items():
if key.endswith('_properties__'):
self.assertFalse(key in all_props)
all_props[key] = val
all_layer_names = set(expected_layer_names) | set(input_layer_names)
for layer_name in all_layer_names:
properties_name = '__%s_properties__' % layer_name
self.assertTrue(properties_name in all_props)
for key in props.keys():
actual_name = all_props[properties_name].get(key)
if layer_name in expected_layer_names:
expected_name = props.get(key)
self.assertEquals(
expected_name,
actual_name,
msg=('expected=%r, actual=%r for key=%r' %
(expected_name, actual_name, key)))
else:
# check the name doesn't appear anywhere else
self.assertEquals(
None,
actual_name,
msg=('got actual=%r for key=%r, expected no value' %
(actual_name, key)))
def test_buffered_land(self):
# the buffered land is a polygon in the boundaries table (sort of),
# but we shouldn't turn it into linestrings of the exterior ring. it
# should stay as a polygon otherwise the border features won't be
# correctly assigned maritime boundary properties, and they'll all
# appear to be maritime boundaries. :-(
from tilequeue.query.common import LayerInfo
from tilequeue.query.rawr import make_rawr_data_fetcher
from tilequeue.tile import coord_to_mercator_bounds
from ModestMaps.Core import Coordinate
from shapely.geometry import Polygon
import shapely.wkb
top_zoom = 10
max_zoom = top_zoom + 6
def min_zoom_fn(shape, props, fid, meta):
return 8
def props_fn(shape, props, fid, meta):
props['kind'] = 'maritime'
return props
z, x, y = (max_zoom, 0, 0)
tile = Coordinate(zoom=z, column=x, row=y)
top_tile = tile.zoomTo(top_zoom).container()
bounds = coord_to_mercator_bounds(tile)
shape = Polygon([
[bounds[0], bounds[1]],
[bounds[0], bounds[3]],
[bounds[2], bounds[1]],
[bounds[0], bounds[1]],
])
props = {
'kind': 'maritime',
'maritime_boundary': True,
'source': 'tilezen.org',
'min_zoom': 0,
}
source = 'tilezen.org'
tables = TestGetTable({
'buffered_land': [
(1, shape.wkb, props),
],
}, source)
layers = {
'boundaries': LayerInfo(min_zoom_fn, props_fn),
}
storage = ConstantStorage(tables)
index_cfg = [{
'type': 'simple',
'table': 'buffered_land',
'layer': 'boundaries',
}]
fetch = make_rawr_data_fetcher(top_zoom, max_zoom, storage, layers,
index_cfg)
for fetcher, _ in fetch.fetch_tiles(_wrap(top_tile)):
read_rows = fetcher(tile.zoom, coord_to_mercator_bounds(tile))
self.assertEqual(len(read_rows), 1)
props = read_rows[0]['__boundaries_properties__']
self.assertEqual(props.get('kind'), 'maritime')
# check no special boundaries geometry - should just be the polygon
self.assertIsNone(read_rows[0].get('__boundaries_geometry__'))
shape = shapely.wkb.loads(read_rows[0]['__geometry__'])
self.assertEqual(shape.geom_type, 'Polygon')