Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
opts.grainstore.mapnik_version = mapnik.versions.mapnik;
}
// Be nice and warn if configured mapnik version is != instaled mapnik version
if (mapnik.versions.mapnik != opts.grainstore.mapnik_version) {
console.warn('WARNING: detected mapnik version (' + mapnik.versions.mapnik + ')' +
' != configured mapnik version (' + opts.grainstore.mapnik_version + ')');
}
// Set carto renderer configuration for MMLStore
if ( ! opts.grainstore.carto_env ) opts.grainstore.carto_env = {};
var cenv = opts.grainstore.carto_env;
if ( ! cenv.validation_data ) cenv.validation_data = {};
if ( ! cenv.validation_data.fonts ) {
mapnik.register_system_fonts();
mapnik.register_default_fonts();
var available_fonts = _.keys(mapnik.fontFiles());
cenv.validation_data.fonts = available_fonts;
}
opts.redis = opts.redis || {};
var redisPool = (opts.redis && opts.redis.pool)
? opts.redis.pool
: new RedisPool(_.extend(opts.redis, {name: 'windshaft:server'}));
// initialize core mml_store
var mml_store_opts = { pool: redisPool };
// force GC off, we'll purge localized resources ourselves
// NOTE: this is not needed anymore with grainstore-0.18.0
opts.grainstore.gc_prob = 0;
var mml_store = new grainstore.MMLStore(mml_store_opts, opts.grainstore);
'host': process.env.PGHOST,
'dbname': process.env.PGDATABASE,
'user': process.env.PGUSER,
'password': process.env.PGPASSWORD,
'port': process.env.PGPORT,
'extent': '-20005048.4188,-9039211.13765,19907487.2779,17096598.5401',
'srid': 3857,
'type': 'postgis'
};
// register datasource adapters for mapnik database connection
if (mapnik.register_default_input_plugins) {
mapnik.register_default_input_plugins();
}
// register fonts for text rendering
mapnik.register_default_fonts();
class DatasourceRenderer implements TileRenderer {
constructor(private getTableDefinitionFn: (tileset: string, dataParams: any) => DataConfig) {}
async getTile({tileset, z, x, y, scale}: TileParams, dataParams: any): Promise {
const bbox = getBbox(z, x, y);
const tileSize = TILE_SIZE * scale;
let map = new mapnik.Map(tileSize, tileSize, PROJ4_STRING);
map.bufferSize = TILE_BUFFER_SIZE;
const layer = new mapnik.Layer('tile', PROJ4_STRING);
const dataSourceConfig = this.getTableDefinitionFn(tileset, dataParams);
const conf = Object.assign(dataSourceConfig, DATASOURCE_CONFIG);
this._autoLoadFonts = uri.query.autoLoadFonts;
this._base = uri.query.base;
uri.query.metatile = +uri.query.metatile;
uri.query.resolution = +uri.query.resolution;
uri.query.bufferSize = +uri.query.bufferSize;
uri.query.tileSize = +uri.query.tileSize;
this._uri = uri;
// Public API to announce how we're metatiling.
this.metatile = uri.query.metatile;
this.bufferSize = uri.query.bufferSize;
// This defaults to true. To disable font auto-loading
// Set ?autoLoadFonts=false in the mapnik URL to disable
if (this._autoLoadFonts) {
if (mapnik.register_default_fonts) mapnik.register_default_fonts();
if (mapnik.register_system_fonts) mapnik.register_system_fonts();
}
// Initialize this map. This wraps `localize()` and calls `create()`
// afterwards to actually create a new Mapnik map object.
Step(function() {
source._loadXML(this);
}, function(err, xml) {
if (err) return error(err);
// https://github.com/mapbox/tilelive-mapnik/issues/25
// there seems to be no value to assinging xml to a property
//source._xml = xml;
source._createMetatileCache();
source._createPool(xml, this);
}, function(err) {
if (err) return error(err);
g.geometry_geom
FROM
geometries as g,
buildings as b
WHERE
g.geometry_id = b.geometry_id
AND b.planning_in_conservation_area = true
) as conservation_area`
}
// register datasource adapters for mapnik database connection
if (mapnik.register_default_input_plugins) {
mapnik.register_default_input_plugins();
}
// register fonts for text rendering
mapnik.register_default_fonts();
const mercator = new SphericalMercator({
size: TILE_SIZE
});
function getBbox(z, x, y) {
return mercator.bbox(x, y, z, false, '900913');
}
function getXYZ(bbox, z) {
return mercator.xyz(bbox, z, false, '900913')
}
function renderTile(tileset, z, x, y, geometryId, cb) {
const bbox = getBbox(z, x, y)
import * as mapnik from "mapnik";
import * as fs from "fs";
import * as path from "path";
mapnik.register_default_fonts();
mapnik.register_default_input_plugins();
const map: mapnik.Map = new mapnik.Map(256, 256);
map.load('./test/stylesheet.xml', function xx(err: Error, map: mapnik.Map) {
if (err) throw err;
map.zoomAll();
const im: mapnik.Image = new mapnik.Image(256, 256);
map.render(im, function xxx(err: Error, im: mapnik.Image) {
if (err) throw err;
im.encode('png', function xxxx(err: Error, buffer: Buffer) {
if (err) throw err;
fs.writeFile('map.png', buffer, function xxxxx(err: Error | null) {
if (err) throw err;
console.log('saved map image to map.png');
});
});
"use strict"
const fs = require('fs');
const path = require('path');
const d3 = require('d3-queue');
var mapnik = require('mapnik');
mapnik.register_default_input_plugins();
mapnik.register_default_fonts()
//console.log(mapnik.fonts());
const find = (dir) =>
fs.readdirSync(dir)
.reduce((files, file) =>
fs.statSync(path.join(dir, file)).isDirectory() ?
files.concat(find(path.join(dir, file))) :
files.concat(path.join(dir, file)),
[]);
function makemappng(basefile, routefile, callback) {
var stylesheet = `
var _ = require('underscore');
var mapnik = require('mapnik');
var RedisPool = require('redis-mpool');
var windshaft = require('../../lib/windshaft');
var DummyMapConfigProvider = require('../../lib/windshaft/models/providers/dummy_mapconfig_provider');
var redisClient = require('redis').createClient(global.environment.redis.port);
mapnik.register_system_fonts();
mapnik.register_default_fonts();
var cartoEnv = {
validation_data: {
fonts: _.keys(mapnik.fontFiles())
}
};
var rendererOptions = global.environment.renderer;
var grainstoreOptions = {
carto_env: cartoEnv,
datasource: global.environment.postgres,
cachedir: global.environment.millstone.cache_basedir,
mapnik_version: global.environment.mapnik_version || mapnik.versions.mapnik
};
var rendererFactoryOptions = {
mapnik: {
grainstore: grainstoreOptions,