function getTiles(minLng, maxLng, minLat, maxLat, zoom, callback) {
var tileMin = tilebelt.pointToTile(minLng, minLat, zoom)
var tileMax = tilebelt.pointToTile(maxLng, maxLat, zoom)
var tiles = []
for(i=tileMin[0];i<tileMax[0] + 1;i++) {
for(j=tileMax[1];j<tileMin[1] + 1;j++) {
tiles.push([i,j])
}
}
callback(tiles)
}
function getTiles(bounds, zoom, callback) {
var tileMin = tilebelt.pointToTile(bounds._southWest.lng, bounds._southWest.lat, zoom)
var tileMax = tilebelt.pointToTile(bounds._northEast.lng, bounds._northEast.lat, zoom)
var tiles = []
for(i=tileMin[0];i<tileMax[0] + 1;i++) {
for(j=tileMax[1];j<tileMin[1] + 1;j++) {
tiles.push([i,j])
}
}
callback(tiles)
}
module.exports = function(tiles, p) {
var bbox = tiles.bbox
var z = tiles.options['zoom-level']
var topLeft = tilebelt.pointToTile(bbox[2], bbox[1], z)
var bottomRight = tilebelt.pointToTile(bbox[0], bbox[3], z)
var tilesToGet = []
for(x=bottomRight[0];x<topLeft[0] + 1;x++) {
for(y=bottomRight[1];y<topLeft[1] + 1;y++) {
tilesToGet.push([x, y, z])
}
}
return getTileUrls(tiles, tilesToGet, p)
}
module.exports = function(o, map) {
if(o.options === null) { return null }
else {
var bbox = map.bbox
var topLeftTile = tilebelt.pointToTile(bbox[0], bbox[3], o.z)
var bottomRightTile = tilebelt.pointToTile(bbox[2], bbox[1], o.z)
var tiles = []
for(x=topLeftTile[0];x<bottomRightTile[0] + 1;x++) {
for(y=topLeftTile[1];y<bottomRightTile[1] + 1;y++) {
tiles.push([x, y, o.z])
}
}
return tiles
}
}
tylr.findTileCoverage = function (feature, zoom) {
var bbox = extent({type: 'FeatureCollection', features: [feature] }),
parentTile = tileBelt.bboxToTile(bbox),
tiles = []
if (parentTile[2] > zoom) {
var tileObj = {}
tileObj[tileBelt.pointToTile(bbox[0], bbox[1], zoom).join('-')] = true
tileObj[tileBelt.pointToTile(bbox[2], bbox[1], zoom).join('-')] = true
tileObj[tileBelt.pointToTile(bbox[0], bbox[3], zoom).join('-')] = true
tileObj[tileBelt.pointToTile(bbox[2], bbox[3], zoom).join('-')] = true
tiles = Object.keys(tileObj)
tiles = tiles.map(function (t) { return t.split('-') })
} else {
tiles = tylr.tilesInParent(parentTile, zoom)
}
var tileJSON, tileMatch = []
tiles.forEach(function (tile) {
tileJSON = tileBelt.tileToGeoJSON(tile)
var coords = [[
[ bbox[0], bbox[1] ],
[ bbox[2], bbox[1] ],
[ bbox[2], bbox[3] ],
[ bbox[0], bbox[3] ],
[ bbox[0], bbox[1] ]
]]
var polygon = {
type: 'Feature',
geometry: {
coordinates: coords,
type: 'Polygon'
}
}
try {
if (intersect(tileJSON, polygon)) {
tileMatch.push(tile.join('-'))
}
} catch (e) {
console.log(e, tile, feature.properties)
}
})
return tileMatch
}
var zoomedTiles = zoomedTiles.map(function(tile){
var centroid =
turf.centroid(
turf.bboxPolygon(
tilebelt.tileToBBOX(tile)
)
);
return tilebelt.pointToTile(
centroid.geometry.coordinates[0],
centroid.geometry.coordinates[1], zoom);
});
function getLocked (geom, limits) {
var locked = [];
if (geom.type === 'Point') {
locked.push(tilebelt.pointToTile(geom.coordinates[0], geom.coordinates[1], limits.max_zoom));
} else if (geom.type === 'MultiPoint') {
var quadkeys = {};
for(var i = 0; i < geom.coordinates.length; i++) {
var tile = tilebelt.pointToTile(geom.coordinates[i][0], geom.coordinates[i][1], limits.max_zoom);
var quadkey = tilebelt.tileToQuadkey(tile);
if(!quadkeys[quadkey]) {
quadkeys[quadkey] = true;
locked.push(tile);
}
}
} else {
var seed = tilebelt.bboxToTile(extent(geom));
if (!seed[3]) seed = [0, 0, 0];
splitSeek(seed, geom, locked, limits);
locked = mergeTiles(locked, limits);
}
return locked;
}
module.exports = function tilePixel (lon, lat, minz, maxz, callback) {
var minZoom = minz
var maxZoom = maxz
var agg = {}
for (var z = minZoom; z < maxZoom; z++) {
var tile = tilebelt.pointToTile(lon, lat, z)
var bbox = tilebelt.tileToBBOX(tile)
var pxy = project(lon, lat, bbox, 256, 256)
agg[z] = {
tile: tile,
px: pxy[0],
py: pxy[1]
}
}
callback(null, agg)
}
module.exports = function(geo, opts){
if(!opts) opts = {};
// normalize geojson data
var fc = JSON.parse(JSON.stringify(geo));
fc = flatten(normalize(fc));
// parse options
// fixed pixel zoom
var zoom;
if(opts.z) zoom = parseFloat(opts.z);
if(opts.zoom) zoom = parseFloat(opts.zoom);
// frame buffer
var frame = 1;
if(opts.f) frame = opts.f;
if(opts.frame) frame = opts.frame;
// overzoom mod
var mod = 0;
if(opts.m) mod = opts.m;
if(opts.mod) mod = opts.mod;
// fixed tile and bbox frame
if(opts.b && typeof opts.b === 'string') opts.bbox = opts.b.split('=').join('').split(',').map(parseFloat);
else if(opts.b) opts.bbox = opts.b;
if(opts.bbox && typeof opts.bbox === 'string') opts.bbox = opts.bbox.split('=').join('').split(',').map(parseFloat);
else if(opts.bbox) opts.bbox = opts.bbox;
else if(opts.t) opts.bbox = tilebelt.tileToBBOX(opts.t.split('/').map(parseFloat));
else if(opts.tile) opts.bbox = tilebelt.tileToBBOX(opts.tile.split('/').map(parseFloat));
// clip geometries to bbox
if(opts.bbox) {
var bboxPoly = turf.bboxPolygon(opts.bbox);
fc.features = fc.features.map(function(f){
var intersect = turf.intersect(bboxPoly, f);
if(intersect) return intersect;
});
fc.features = fc.features.filter(function(f){
if(f) return f;
});
}
// auto pixel zoom if not specified
if(!(zoom>0)) {
var bbox = turf.extent(fc);
var found = false;
var z = 3;
while(!found && z < 28) {
// x fit
var lineTilesX = tileCover.tiles(
turf.linestring([[bbox[0], bbox[1]], [bbox[2], bbox[1]]]).geometry,
{min_zoom: z, max_zoom: z}
);
var lineXs = lineTilesX.map(function(t){ return t[0]; });
var lineMinX = lineXs.reduce(function(a, b){
if(a < b) return a;
else return b;
});
var lineMaxX = lineXs.reduce(function(a, b){
if(a > b) return a;
else return b;
});
var diffX = lineMaxX - lineMinX;
// y fit
var lineTilesY = tileCover.tiles(
turf.linestring([[bbox[0], bbox[1]], [bbox[0], bbox[3]]]).geometry,
{min_zoom: z, max_zoom: z}
);
var lineYs = lineTilesY.map(function(t){return t[1]; });
var lineMinY = lineYs.reduce(function(a, b){
if(a < b) return a;
else return b;
});
var lineMaxY = lineYs.reduce(function(a, b){
if(a > b) return a;
else return b;
});
var diffY = lineMaxY - lineMinY;
if (diffX > 30 || diffY > 23) {
found = true;
zoom = z;
}
z++;
}
}
// apply overzoom mod
zoom += mod;
// rasterize geometries to tile pixels
var tiles = [];
fc.features.forEach(function(f) {
var newTiles = tileCover.tiles(f.geometry, {min_zoom: zoom, max_zoom: zoom})
.map(function(t){
t[2] = f.geometry.type;
return t;
});
tiles = tiles.concat(newTiles);
});
// fit frame to bbox and filter out of scope tile pixels
if(opts.bbox) {
// override frame if bbox or tile is given
frame = 0;
var topLeft = tilebelt.pointToTile(opts.bbox[0], opts.bbox[3], zoom);
var bottomRight = tilebelt.pointToTile(opts.bbox[2], opts.bbox[1], zoom);
// clip tile pixels outside the bbox frame
tiles = tiles.filter(function(t) {
if(t[0] >= topLeft[0] &&
t[0] <= bottomRight[0] &&
t[1] >= topLeft[1] &&
t[1] <= bottomRight[1]) return true;
});
tiles.push(topLeft);
tiles.push(bottomRight);
}
// find frame tile pixel bounds
var xs = tiles.map(function(t){return t[0]; });
var ys = tiles.map(function(t) { return t[1]; });
var minX = xs.reduce(function(a, b){
if(a < b) return a;
else return b;
});
var minY = ys.reduce(function(a, b){
if(a < b) return a;
else return b;
});
var maxX = xs.reduce(function(a, b){
if(a > b) return a;
else return b;
});
var maxY = ys.reduce(function(a, b){
if(a > b) return a;
else return b;
});
// apply frame buffer
minX -= frame;
minY -= frame;
maxX += frame;
maxY += frame;
var tileHash = {};
tiles.forEach(function(tile){
tileHash[tile[0]+'/'+tile[1]] = tile[2];
});
// write tile pixels
var map = '';
var x = minX;
var y = minY;
while(y <= maxY) {
while(x <= maxX) {
if(tileHash[x+'/'+y]) {
if(tileHash[x+'/'+y] === 'Polygon' || tileHash[x+'/'+y] === 'MultiPolygon') map+=colors.bgGreen.green('::');
else if(tileHash[x+'/'+y] === 'LineString' || tileHash[x+'/'+y] === 'MultiLineString') map+=colors.bgBlack.black('XX');
else if(tileHash[x+'/'+y] === 'Point' || tileHash[x+'/'+y] === 'MultiPoint') map+=colors.bgRed.red('@@');
else map+=colors.bgBlue(' ');
}
else map+=colors.bgBlue(' ');
x++;
}
map+='\n';
x = minX;
y++;
}
// output ascii render
return map;
}