Promise.all(shapePromises).then(geometries => {
const shapeBundles = zip(shapeIds, shapeIds.map(shapeId => shapes[shapeId][0].route), geometries)
const geoJSON = {type: "FeatureCollection", features: shapeBundles.map(toFeature)}
this.tileIndex = geojsonVt(geoJSON, {maxZoom: 20, buffer: 512}); //TODO: this should be configurable
console.log("all ready")
callback(null, this)
}).catch((err) => {
this.loadGeoJSON(params, (err, data) => {
if (err || !data) {
return callback(err);
} else if (typeof data !== 'object') {
return callback(new Error("Input data is not a valid GeoJSON object."));
} else {
rewind(data, true);
try {
this._geoJSONIndex = params.cluster ?
supercluster(params.superclusterOptions).load(data.features) :
geojsonvt(data, params.geojsonVtOptions);
} catch (err) {
return callback(err);
}
this.loaded = {};
const result = {};
if (perf) {
const resourceTimingData = perf.finish();
// it's necessary to eval the result of getEntriesByName() here via parse/stringify
// late evaluation in the main thread causes TypeError: illegal invocation
if (resourceTimingData) {
result.resourceTiming = {};
result.resourceTiming[params.source] = JSON.parse(JSON.stringify(resourceTimingData));
}
}
callback(null, result);
}
});
onmessage = function (e) {
if (e.data[0] === 'slice') {
// Given a blob of GeoJSON and some topojson/geojson-vt options, do the slicing.
var geojson = e.data[1];
options = e.data[2];
if (geojson.type && geojson.type === 'Topology') {
for (var layerName in geojson.objects) {
slicers[layerName] = geojsonvt(
topojson.feature(geojson, geojson.objects[layerName])
, options);
}
} else {
slicers[options.vectorTileLayerName] = geojsonvt(geojson, options);
}
} else if (e.data[0] === 'get') {
// Gets the vector tile for the given coordinates, sends it back as a message
var coords = e.data[1];
var tileLayers = {};
for (var layerName in slicers) {
var slicedTileLayer = slicers[layerName].getTile(coords.z, coords.x, coords.y);
if (slicedTileLayer) {
var vectorTileLayer = {
features: [],
extent: options.extent,
name: options.vectorTileLayerName,
length: slicedTileLayer.features.length
}
for (var i in slicedTileLayer.features) {
var feat = {
geometry: slicedTileLayer.features[i].geometry,
properties: slicedTileLayer.features[i].tags,
type: slicedTileLayer.features[i].type // 1 = point, 2 = line, 3 = polygon
}
vectorTileLayer.features.push(feat);
}
tileLayers[layerName] = vectorTileLayer;
}
}
postMessage({ layers: tileLayers, coords: coords });
}
}
/**
* Index the data using either geojson-vt or supercluster
* @param {GeoJSON} data
* @param {Object} params forwarded from loadTile.
* @param {callback} (err, indexedData)
* @private
*/
_indexData(data, params, callback) {
try {
if (params.cluster) {
callback(null, supercluster(params.superclusterOptions).load(data.features));
} else {
callback(null, geojsonvt(data, params.geojsonVtOptions));
}
} catch (err) {
return callback(err);
}
}
var indexData = function(err, data) {
if (err) return callback(err);
if (typeof data != 'object') {
return callback(new Error("Input data is not a valid GeoJSON object."));
}
try {
this.geoJSONIndexes[params.source] = geojsonvt(data, params.geojsonVtOptions);
} catch (err) {
return callback(err);
}
callback(null);
}.bind(this);
var indexData = function(err, data) {
rewind(data, true);
if (err) return callback(err);
if (typeof data != 'object') {
return callback(new Error("Input data is not a valid GeoJSON object."));
}
try {
this.geoJSONIndexes[params.source] = params.cluster ?
supercluster(params.superclusterOptions).load(data.features) :
geojsonvt(data, params.geojsonVtOptions);
} catch (err) {
return callback(err);
}
callback(null);
}.bind(this);
var vtpbf = require('vt-pbf');
var geojsonVt = require('geojson-vt');
var fs = require('fs');
var orig = JSON.parse(fs.readFileSync(__dirname + '/data/data.geojson'))
var tileindex = geojsonVt(orig);
// z13-7032-2975
var tile = tileindex.getTile(13, 7032, 2975);
console.log(tileindex.tileCoords); // [{z: 0, x: 0, y: 0}, ...]
// pass in an object mapping layername -> tile object
var buff = vtpbf.fromGeojsonVt({ 'geojsonLayer': tile });
fs.writeFileSync('test-tile.pbf', buff);
var fs = require('fs')
var path = require('path')
var geojsonVt = require('geojson-vt')
var Pbf = require('pbf')
var VectorTile = require('vector-tile').VectorTile
var Benchmark = require('benchmark')
var serialize = require('../')
var raw = fs.readFileSync(path.join(__dirname, '../test/fixtures/rectangle-1.0.0.pbf'))
var rawTile = new VectorTile(new Pbf(raw))
serialize(rawTile)
var properties = JSON.parse(fs.readFileSync(path.join(__dirname, 'properties.geojson')))
var propertiesTile = geojsonVt(properties).getTile(0, 0, 0)
var simple = JSON.parse(fs.readFileSync(path.join(__dirname, 'rectangle.geojson')))
var simpleTile = geojsonVt(simple).getTile(0, 0, 0)
var suite = new Benchmark.Suite('vt-pbf')
suite
.add('raw', function () {
serialize(rawTile)
})
.add('simple', function () {
serialize.fromGeojsonVt({ 'geojsonLayer': simpleTile })
})
.add('lots of properties', function () {
serialize.fromGeojsonVt({ 'geojsonLayer': propertiesTile })
})
.on('cycle', function (event) {
console.log(String(event.target))
var indexData = function(err, data) {
if (err) return callback(err);
this.geoJSONIndexes[params.source] = geojsonvt(data, params.geojsonVtOptions);
callback(null);
}.bind(this);