def _format_feature_layers(processed_feature_layers, coord, formats,
unpadded_bounds, scale, buffer_cfg):
# the nominal zoom is the "display scale" zoom, which may not correspond
# to actual tile coordinates in future versions of the code. it just
# becomes a measure of the scale between tile features and intended
# display size.
nominal_zoom = coord.zoom
meters_per_pixel_dim = calc_meters_per_pixel_dim(nominal_zoom)
# topojson formatter expects bounds to be in lnglat
unpadded_bounds_lnglat = (
mercator_point_to_lnglat(unpadded_bounds[0], unpadded_bounds[1]) +
mercator_point_to_lnglat(unpadded_bounds[2], unpadded_bounds[3]))
# now, perform the format specific transformations
# and format the tile itself
formatted_tiles = []
layer = 'all'
for format in formats:
formatted_tile = _create_formatted_tile(processed_feature_layers,
format, scale, unpadded_bounds,
unpadded_bounds_lnglat, coord,
layer, meters_per_pixel_dim,
buffer_cfg)
formatted_tiles.append(formatted_tile)
return formatted_tiles
def reformat_selected_layers(
json_tile_data, layer_data, coord, format, buffer_cfg):
"""
Reformats the selected (subset of) layers from a JSON tile containing all
layers. We store "tiles of record" containing all layers as JSON, and this
function does most of the work of reading that, pruning the layers which
aren't needed and reformatting it to the desired output format.
"""
feature_layers = decode_json_tile_for_layers(json_tile_data, layer_data)
bounds_merc = coord_to_mercator_bounds(coord)
bounds_lnglat = (
mercator_point_to_lnglat(bounds_merc[0], bounds_merc[1]) +
mercator_point_to_lnglat(bounds_merc[2], bounds_merc[3]))
meters_per_pixel_dim = calc_meters_per_pixel_dim(coord.zoom)
scale = 4096
feature_layers = transform_feature_layers_shape(
feature_layers, format, scale, bounds_merc,
coord, meters_per_pixel_dim, buffer_cfg)
tile_data_file = StringIO()
format.format_tile(tile_data_file, feature_layers, coord,
bounds_merc, bounds_lnglat)
tile_data = tile_data_file.getvalue()
return tile_data
def reformat_selected_layers(
json_tile_data, layer_data, coord, format, buffer_cfg):
"""
Reformats the selected (subset of) layers from a JSON tile containing all
layers. We store "tiles of record" containing all layers as JSON, and this
function does most of the work of reading that, pruning the layers which
aren't needed and reformatting it to the desired output format.
"""
feature_layers = decode_json_tile_for_layers(json_tile_data, layer_data)
bounds_merc = coord_to_mercator_bounds(coord)
bounds_lnglat = (
mercator_point_to_lnglat(bounds_merc[0], bounds_merc[1]) +
mercator_point_to_lnglat(bounds_merc[2], bounds_merc[3]))
meters_per_pixel_dim = calc_meters_per_pixel_dim(coord.zoom)
scale = 4096
feature_layers = transform_feature_layers_shape(
feature_layers, format, scale, bounds_merc,
coord, meters_per_pixel_dim, buffer_cfg)
tile_data_file = StringIO()
format.format_tile(tile_data_file, feature_layers, coord,
bounds_merc, bounds_lnglat)
tile_data = tile_data_file.getvalue()
return tile_data
def process_coord(coord,
feature_layers,
post_process_data,
formats,
unpadded_bounds,
cut_coords,
layers_to_format,
buffer_cfg,
scale=4096):
feature_layers, extra_data = _preprocess_data(feature_layers)
children_formatted_tiles = []
if cut_coords:
for cut_coord in cut_coords:
unpadded_cut_bounds = coord_to_mercator_bounds(cut_coord)
meters_per_pixel_dim = calc_meters_per_pixel_dim(cut_coord.zoom)
child_feature_layers = _cut_coord(feature_layers,
unpadded_cut_bounds,
meters_per_pixel_dim, buffer_cfg)
child_formatted_tiles = _process_feature_layers(
child_feature_layers, cut_coord, post_process_data, formats,
unpadded_cut_bounds, scale, layers_to_format, buffer_cfg)
children_formatted_tiles.extend(child_formatted_tiles)
coord_formatted_tiles = _process_feature_layers(feature_layers, coord,
post_process_data, formats,
unpadded_bounds, scale,
layers_to_format,
buffer_cfg)
all_formatted_tiles = coord_formatted_tiles + children_formatted_tiles
return all_formatted_tiles, extra_data
def test_z10_compare_with_dim(self):
from tilequeue.tile import calc_meters_per_pixel_dim
meters_per_pixel_dim = calc_meters_per_pixel_dim(10)
meters_per_pixel_area = self._call_fut(10)
exp_meters_per_pixel_area = (meters_per_pixel_dim *
meters_per_pixel_dim)
self.assertAlmostEquals(exp_meters_per_pixel_area,
meters_per_pixel_area)
def test_z10_compare_with_dim(self):
from tilequeue.tile import calc_meters_per_pixel_dim
meters_per_pixel_dim = calc_meters_per_pixel_dim(10)
meters_per_pixel_area = self._call_fut(10)
exp_meters_per_pixel_area = (
meters_per_pixel_dim * meters_per_pixel_dim)
self.assertAlmostEquals(
exp_meters_per_pixel_area, meters_per_pixel_area)
def _cut_child_tiles(feature_layers, cut_coord, formats, scale, buffer_cfg):
unpadded_cut_bounds = coord_to_mercator_bounds(cut_coord)
meters_per_pixel_dim = calc_meters_per_pixel_dim(cut_coord.zoom)
cut_feature_layers = _cut_coord(feature_layers, unpadded_cut_bounds,
meters_per_pixel_dim, buffer_cfg)
return _format_feature_layers(cut_feature_layers, cut_coord, formats,
unpadded_cut_bounds, scale, buffer_cfg)
def build_feature_queries(unpadded_bounds, layer_data, zoom):
meters_per_pixel_dim = calc_meters_per_pixel_dim(zoom)
queries_to_execute = []
for layer_datum in layer_data:
query_bounds_pad_fn = layer_datum['query_bounds_pad_fn']
padded_bounds = query_bounds_pad_fn(unpadded_bounds,
meters_per_pixel_dim)
query_generator = layer_datum['query_generator']
query = query_generator(padded_bounds, zoom)
queries_to_execute.append((layer_datum, query, padded_bounds))
return queries_to_execute
def build_feature_queries(unpadded_bounds, layer_data, zoom):
meters_per_pixel_dim = calc_meters_per_pixel_dim(zoom)
queries_to_execute = []
for layer_datum in layer_data:
query_bounds_pad_fn = layer_datum['query_bounds_pad_fn']
padded_bounds = query_bounds_pad_fn(
unpadded_bounds, meters_per_pixel_dim)
query_generator = layer_datum['query_generator']
query = query_generator(padded_bounds, zoom)
queries_to_execute.append((layer_datum, query, padded_bounds))
return queries_to_execute
def _cut_child_tiles(
feature_layers, cut_coord, nominal_zoom, formats, scale, buffer_cfg):
unpadded_cut_bounds = coord_to_mercator_bounds(cut_coord)
meters_per_pixel_dim = calc_meters_per_pixel_dim(nominal_zoom)
cut_feature_layers = _cut_coord(
feature_layers, unpadded_cut_bounds, meters_per_pixel_dim, buffer_cfg)
return _format_feature_layers(
cut_feature_layers, cut_coord, nominal_zoom, formats,
unpadded_cut_bounds, scale, buffer_cfg)
def _format_feature_layers(
processed_feature_layers, coord, nominal_zoom, formats,
unpadded_bounds, scale, buffer_cfg):
meters_per_pixel_dim = calc_meters_per_pixel_dim(nominal_zoom)
# topojson formatter expects bounds to be in lnglat
unpadded_bounds_lnglat = (
mercator_point_to_lnglat(unpadded_bounds[0], unpadded_bounds[1]) +
mercator_point_to_lnglat(unpadded_bounds[2], unpadded_bounds[3]))
# now, perform the format specific transformations
# and format the tile itself
formatted_tiles = []
layer = 'all'
for format in formats:
formatted_tile = _create_formatted_tile(
processed_feature_layers, format, scale, unpadded_bounds,
unpadded_bounds_lnglat, coord, nominal_zoom, layer,
meters_per_pixel_dim, buffer_cfg)
formatted_tiles.append(formatted_tile)
return formatted_tiles
def _format_feature_layers(processed_feature_layers, coord, nominal_zoom,
formats, unpadded_bounds, scale, buffer_cfg):
meters_per_pixel_dim = calc_meters_per_pixel_dim(nominal_zoom)
# topojson formatter expects bounds to be in lnglat
unpadded_bounds_lnglat = (
mercator_point_to_lnglat(unpadded_bounds[0], unpadded_bounds[1]) +
mercator_point_to_lnglat(unpadded_bounds[2], unpadded_bounds[3]))
# now, perform the format specific transformations
# and format the tile itself
formatted_tiles = []
layer = 'all'
for format in formats:
formatted_tile = _create_formatted_tile(processed_feature_layers,
format, scale, unpadded_bounds,
unpadded_bounds_lnglat, coord,
nominal_zoom, layer,
meters_per_pixel_dim,
buffer_cfg)
formatted_tiles.append(formatted_tile)
return formatted_tiles
def process_coord(coord, feature_layers, post_process_data, formats,
unpadded_bounds, cut_coords, layers_to_format,
buffer_cfg, scale=4096):
feature_layers, extra_data = _preprocess_data(feature_layers)
children_formatted_tiles = []
if cut_coords:
for cut_coord in cut_coords:
unpadded_cut_bounds = coord_to_mercator_bounds(cut_coord)
meters_per_pixel_dim = calc_meters_per_pixel_dim(cut_coord.zoom)
child_feature_layers = _cut_coord(
feature_layers, unpadded_cut_bounds, meters_per_pixel_dim,
buffer_cfg)
child_formatted_tiles = _process_feature_layers(
child_feature_layers, cut_coord, post_process_data, formats,
unpadded_cut_bounds, scale, layers_to_format, buffer_cfg)
children_formatted_tiles.extend(child_formatted_tiles)
coord_formatted_tiles = _process_feature_layers(
feature_layers, coord, post_process_data, formats, unpadded_bounds,
scale, layers_to_format, buffer_cfg)
all_formatted_tiles = coord_formatted_tiles + children_formatted_tiles
return all_formatted_tiles, extra_data
def _call_fut(self, zoom):
from tilequeue.tile import calc_meters_per_pixel_dim
result = calc_meters_per_pixel_dim(zoom)
return result
def _process_feature_layers(feature_layers, coord, post_process_data, formats,
unpadded_bounds, scale, layers_to_format,
buffer_cfg):
processed_feature_layers = []
# filter, and then transform each layer as necessary
for feature_layer in feature_layers:
layer_datum = feature_layer['layer_datum']
layer_name = layer_datum['name']
features = feature_layer['features']
transform_fn_names = layer_datum['transform_fn_names']
if transform_fn_names:
transform_fns = resolve_transform_fns(transform_fn_names)
layer_transform_fn = make_transform_fn(transform_fns)
else:
layer_transform_fn = None
# perform any specific layer transformations
if layer_transform_fn is None:
processed_features = features
else:
processed_features = []
for feature in features:
shape, props, feature_id = feature
shape, props, feature_id = layer_transform_fn(
shape, props, feature_id, coord.zoom)
transformed_feature = shape, props, feature_id
processed_features.append(transformed_feature)
sort_fn_name = layer_datum['sort_fn_name']
if sort_fn_name:
sort_fn = resolve(sort_fn_name)
processed_features = sort_fn(processed_features, coord.zoom)
feature_layer = dict(
name=layer_name,
features=processed_features,
layer_datum=layer_datum,
padded_bounds=feature_layer['padded_bounds'],
)
processed_feature_layers.append(feature_layer)
# post-process data here, before it gets formatted
processed_feature_layers = _postprocess_data(processed_feature_layers,
post_process_data, coord,
unpadded_bounds)
meters_per_pixel_dim = calc_meters_per_pixel_dim(coord.zoom)
# topojson formatter expects bounds to be in lnglat
unpadded_bounds_lnglat = (
mercator_point_to_lnglat(unpadded_bounds[0], unpadded_bounds[1]) +
mercator_point_to_lnglat(unpadded_bounds[2], unpadded_bounds[3]))
# now, perform the format specific transformations
# and format the tile itself
formatted_tiles = []
layer = 'all'
for format in formats:
formatted_tile = _create_formatted_tile(processed_feature_layers,
format, scale, unpadded_bounds,
unpadded_bounds_lnglat, coord,
layer, meters_per_pixel_dim,
buffer_cfg)
formatted_tiles.append(formatted_tile)
# this assumes that we only store single layers, and no combinations
for layer, formats, zoom_start, zoom_until in layers_to_format:
if not (zoom_start <= coord.zoom <= zoom_until):
continue
for feature_layer in processed_feature_layers:
if feature_layer['name'] == layer:
pruned_feature_layers = [feature_layer]
for format in formats:
formatted_tile = _create_formatted_tile(
pruned_feature_layers, format, scale, unpadded_bounds,
unpadded_bounds_lnglat, coord, layer,
meters_per_pixel_dim, buffer_cfg)
formatted_tiles.append(formatted_tile)
break
return formatted_tiles
def _call_fut(self, zoom):
from tilequeue.tile import calc_meters_per_pixel_dim
result = calc_meters_per_pixel_dim(zoom)
return result
def _process_feature_layers(
feature_layers, coord, post_process_data, formats, unpadded_bounds,
scale, buffer_cfg):
# the nominal zoom is the "display scale" zoom, which may not correspond
# to actual tile coordinates in future versions of the code. it just
# becomes a measure of the scale between tile features and intended
# display size.
nominal_zoom = coord.zoom
processed_feature_layers = []
# filter, and then transform each layer as necessary
for feature_layer in feature_layers:
layer_datum = feature_layer['layer_datum']
layer_name = layer_datum['name']
features = feature_layer['features']
transform_fn_names = layer_datum['transform_fn_names']
if transform_fn_names:
transform_fns = resolve_transform_fns(transform_fn_names)
layer_transform_fn = make_transform_fn(transform_fns)
else:
layer_transform_fn = None
# perform any specific layer transformations
if layer_transform_fn is None:
processed_features = features
else:
processed_features = []
for feature in features:
shape, props, feature_id = feature
shape, props, feature_id = layer_transform_fn(
shape, props, feature_id, nominal_zoom)
transformed_feature = shape, props, feature_id
processed_features.append(transformed_feature)
sort_fn_name = layer_datum['sort_fn_name']
if sort_fn_name:
sort_fn = resolve(sort_fn_name)
processed_features = sort_fn(processed_features, nominal_zoom)
feature_layer = dict(
name=layer_name,
features=processed_features,
layer_datum=layer_datum,
padded_bounds=feature_layer['padded_bounds'],
)
processed_feature_layers.append(feature_layer)
# post-process data here, before it gets formatted
processed_feature_layers = _postprocess_data(
processed_feature_layers, post_process_data, nominal_zoom,
unpadded_bounds)
meters_per_pixel_dim = calc_meters_per_pixel_dim(nominal_zoom)
# topojson formatter expects bounds to be in lnglat
unpadded_bounds_lnglat = (
mercator_point_to_lnglat(unpadded_bounds[0], unpadded_bounds[1]) +
mercator_point_to_lnglat(unpadded_bounds[2], unpadded_bounds[3]))
# now, perform the format specific transformations
# and format the tile itself
formatted_tiles = []
layer = 'all'
for format in formats:
formatted_tile = _create_formatted_tile(
processed_feature_layers, format, scale, unpadded_bounds,
unpadded_bounds_lnglat, coord, layer, meters_per_pixel_dim,
buffer_cfg)
formatted_tiles.append(formatted_tile)
return formatted_tiles
def _process_feature_layers(
feature_layers, coord, post_process_data, formats, unpadded_bounds,
scale, layers_to_format, buffer_cfg):
processed_feature_layers = []
# filter, and then transform each layer as necessary
for feature_layer in feature_layers:
layer_datum = feature_layer['layer_datum']
layer_name = layer_datum['name']
features = feature_layer['features']
transform_fn_names = layer_datum['transform_fn_names']
if transform_fn_names:
transform_fns = resolve_transform_fns(transform_fn_names)
layer_transform_fn = make_transform_fn(transform_fns)
else:
layer_transform_fn = None
# perform any specific layer transformations
if layer_transform_fn is None:
processed_features = features
else:
processed_features = []
for feature in features:
shape, props, feature_id = feature
shape, props, feature_id = layer_transform_fn(
shape, props, feature_id, coord.zoom)
transformed_feature = shape, props, feature_id
processed_features.append(transformed_feature)
sort_fn_name = layer_datum['sort_fn_name']
if sort_fn_name:
sort_fn = resolve(sort_fn_name)
processed_features = sort_fn(processed_features, coord.zoom)
feature_layer = dict(
name=layer_name,
features=processed_features,
layer_datum=layer_datum,
padded_bounds=feature_layer['padded_bounds'],
)
processed_feature_layers.append(feature_layer)
# post-process data here, before it gets formatted
processed_feature_layers = _postprocess_data(
processed_feature_layers, post_process_data, coord, unpadded_bounds)
meters_per_pixel_dim = calc_meters_per_pixel_dim(coord.zoom)
# topojson formatter expects bounds to be in lnglat
unpadded_bounds_lnglat = (
mercator_point_to_lnglat(unpadded_bounds[0], unpadded_bounds[1]) +
mercator_point_to_lnglat(unpadded_bounds[2], unpadded_bounds[3]))
# now, perform the format specific transformations
# and format the tile itself
formatted_tiles = []
layer = 'all'
for format in formats:
formatted_tile = _create_formatted_tile(
processed_feature_layers, format, scale, unpadded_bounds,
unpadded_bounds_lnglat, coord, layer, meters_per_pixel_dim,
buffer_cfg)
formatted_tiles.append(formatted_tile)
# this assumes that we only store single layers, and no combinations
for layer, formats, zoom_start, zoom_until in layers_to_format:
if not (zoom_start <= coord.zoom <= zoom_until):
continue
for feature_layer in processed_feature_layers:
if feature_layer['name'] == layer:
pruned_feature_layers = [feature_layer]
for format in formats:
formatted_tile = _create_formatted_tile(
pruned_feature_layers, format, scale, unpadded_bounds,
unpadded_bounds_lnglat, coord, layer,
meters_per_pixel_dim, buffer_cfg)
formatted_tiles.append(formatted_tile)
break
return formatted_tiles