double bound_x0;

double bound_y0;

double bound_x1;

double bound_y1;

int aspect_x;

int aspect_y;

Map map;

const char *host;

const char *htcphost;

const char *output_format;

const char *xmlfile;

const char *xmlname;

const char *xmluri;

double scale;

int htcpsock;

int maxzoom;

int minzoom;

int ok;

int tilesize;

parameterize_function_ptr parameterize_function;

struct projectionconfig *prj;

struct storage_backend *store;

xmlmapconfig() : map(256, 256) {}

{

DIR *fonts = opendir(font_dir);

if (!fonts) {

g_logger(G_LOG_LEVEL_CRITICAL, "Unable to open font directory: %s", font_dir);

return;

}

closedir(fonts);

g_logger(G_LOG_LEVEL_INFO, "Loading fonts%sfrom directory '%s'", recurse ? " recursively " : " ", font_dir);

freetype_engine::register_fonts(font_dir, recurse);

freetype_engine::font_file_mapping_type face_name_mappings = freetype_engine::get_mapping();

freetype_engine::font_file_mapping_type::iterator face_name_mappings_iterator = face_name_mappings.begin();

while (face_name_mappings_iterator != face_name_mappings.end()) {

const char *face_name = face_name_mappings_iterator->first.c_str();

const char *font_file_name = face_name_mappings_iterator->second.second.c_str();

g_logger(G_LOG_LEVEL_DEBUG, "Loaded font face '%s' from file '%s'", face_name, font_file_name);

face_name_mappings_iterator++;

}

{

unsigned int i;

char *tmp = (char *)malloc(20);

for (i = 0; i < m.layer_count(); i++) {

layer &l = m.get_layer(i);

parameters params = l.datasource()->params();

if (params.find("max_size") == params.end()) {

snprintf(tmp, 20, "%i", num_threads + 2);

params["max_size"] = std::string(tmp);

}

l.set_datasource(datasource_cache::instance().create(params));

}

free(tmp);

{

int oob, limit;

// Validate tile co-ordinates

oob = (z < map->minzoom || z > map->maxzoom);

if (!oob) {

// valid x/y for tiles are 0 ... 2^zoom-1

limit = (1 << z);

oob = (x < 0 || x > (limit * map->prj->aspect_x - 1) || y < 0 || y > (limit * map->prj->aspect_y - 1));

}

if (oob) {

g_logger(G_LOG_LEVEL_INFO, "got bad co-ords: x(%d) y(%d) z(%d)", x, y, z);

}

return !oob;

{

int render_size_tx = MIN(METATILE, prj->aspect_x * (1 << z));

int render_size_ty = MIN(METATILE, prj->aspect_y * (1 << z));

double p0x = prj->bound_x0 + (prj->bound_x1 - prj->bound_x0) * ((double)x / (double)(prj->aspect_x * 1 << z));

double p0y = (prj->bound_y1 - (prj->bound_y1 - prj->bound_y0) * (((double)y + render_size_ty) / (double)(prj->aspect_y * 1 << z)));

double p1x = prj->bound_x0 + (prj->bound_x1 - prj->bound_x0) * (((double)x + render_size_tx) / (double)(prj->aspect_x * 1 << z));

double p1y = (prj->bound_y1 - (prj->bound_y1 - prj->bound_y0) * ((double)y / (double)(prj->aspect_y * 1 << z)));

g_logger(G_LOG_LEVEL_DEBUG, "Rendering projected coordinates %i %i %i -> %f|%f %f|%f to a %i x %i tile", z, x, y, p0x, p0y, p1x, p1y, render_size_tx, render_size_ty);

mapnik::box2d<double> bbox(p0x, p0y, p1x, p1y);

return bbox;

{

unsigned int render_size_tx = MIN(METATILE, map->prj->aspect_x * (1 << z));

unsigned int render_size_ty = MIN(METATILE, map->prj->aspect_y * (1 << z));

map->map.resize(render_size_tx * map->tilesize, render_size_ty * map->tilesize);

map->map.zoom_to_box(tile2prjbounds(map->prj, x, y, z));

if (map->map.buffer_size() == 0) { // Only set buffer size if the buffer size isn't explicitly set in the mapnik stylesheet.

map->map.set_buffer_size((map->tilesize >> 1) * map->scale);

}

// m.zoom(size+1);

mapnik::image_32 buf(render_size_tx * map->tilesize, render_size_ty * map->tilesize);

try {

if (map->parameterize_function) {

Map map_parameterized = map->map;

map->parameterize_function(map_parameterized, options);

map_parameterized.load_fonts();

mapnik::agg_renderer<mapnik::image_32> ren(map_parameterized, buf, map->scale);

ren.apply();

} else {

mapnik::agg_renderer<mapnik::image_32> ren(map->map, buf, map->scale);

ren.apply();

}

} catch (std::exception const &ex) {

g_logger(G_LOG_LEVEL_ERROR, "failed to render TILE %s %d %d-%d %d-%d", map->xmlname, z, x, x + render_size_tx - 1, y, y + render_size_ty - 1);

g_logger(G_LOG_LEVEL_ERROR, " reason: %s", ex.what());

return cmdNotDone;

}

// Split the meta tile into an NxN grid of tiles

unsigned int xx, yy;

for (yy = 0; yy < render_size_ty; yy++) {

for (xx = 0; xx < render_size_tx; xx++) {

mapnik::image_view<mapnik::image<mapnik::rgba8_t >> vw1(xx * map->tilesize, yy * map->tilesize, map->tilesize, map->tilesize, buf);

struct mapnik::image_view_any vw(vw1);

tiles.set(xx, yy, save_to_string(vw, map->output_format));

}

}

return cmdDone; // OK

{

char filename[PATH_MAX];

char tmp[PATH_MAX];

double p0x = x * 256.0;

double p0y = (y + 1) * 256.0;

double p1x = (x + 1) * 256.0;

double p1y = y * 256.0;

tiling.fromPixelToLL(p0x, p0y, z);

tiling.fromPixelToLL(p1x, p1y, z);

prj.forward(p0x, p0y);

prj.forward(p1x, p1y);

mapnik::box2d<double> bbox(p0x, p0y, p1x, p1y);

bbox.width(bbox.width() * 2);

bbox.height(bbox.height() * 2);

m.zoomToBox(bbox);

mapnik::image_32 buf(RENDER_SIZE, RENDER_SIZE);

mapnik::agg_renderer<mapnik::image_32> ren(m, buf);

ren.apply();

xyz_to_path(filename, sizeof(filename), tile_dir, xmlname, x, y, z);

if (mkdirp(filename)) {

return cmdNotDone;

}

snprintf(tmp, sizeof(tmp), "%s.tmp", filename);

mapnik::image_view<mapnik::image_data_32> vw(128, 128, 256, 256, buf.data());

g_logger(G_LOG_LEVEL_DEBUG, "Render %i %i %i %s", z, x, y, filename)

mapnik::save_to_file(vw, tmp, outputFormat);

if (rename(tmp, filename)) {

perror(tmp);

return cmdNotDone;

}

return cmdDone; // OK

{

g_logger(G_LOG_LEVEL_INFO, "Renderd is using mapnik version %i.%i.%i", MAPNIK_MAJOR_VERSION, MAPNIK_MINOR_VERSION, MAPNIK_PATCH_VERSION);

mapnik::datasource_cache::instance().register_datasources(plugins_dir);

load_fonts(font_dir, font_dir_recurse);