{

agg_renderer_visitor(mapnik::Map const& m,

mapnik::request const& req,

mapnik::attributes const& vars,

double scale_factor,

unsigned offset_x,

unsigned offset_y,

double scale_denominator)

: m_(m),

req_(req),

vars_(vars),

scale_factor_(scale_factor),

offset_x_(offset_x),

offset_y_(offset_y),

scale_denominator_(scale_denominator) {}

void operator()(mapnik::image_rgba8& pixmap)

{

mapnik::agg_renderer<mapnik::image_rgba8> ren(m_, req_, vars_, pixmap, scale_factor_, offset_x_, offset_y_);

ren.apply(scale_denominator_);

}

template <typename T>

void operator()(T&)

{

throw std::runtime_error("This image type is not currently supported for rendering.");

}

private:

mapnik::Map const& m_;

mapnik::request const& req_;

mapnik::attributes const& vars_;

double scale_factor_;

unsigned offset_x_;

unsigned offset_y_;

double scale_denominator_;

{

using Base = Napi::AsyncWorker;

AsyncRender(Map* map_obj, Napi::Function const& callback)

: Base(callback),

map_obj_(map_obj) {}

~AsyncRender() {} // an empty dtor

void OnWorkComplete(Napi::Env env, napi_status status) override

{

if (map_obj_)

{

map_obj_->release();

map_obj_->Unref();

}

Base::OnWorkComplete(env, status);

}

protected:

Map* map_obj_;

{

AsyncRenderImage(Map* map_obj, image_ptr const& image,

double scale_factor, double scale_denominator,

int buffer_size, unsigned offset_x, unsigned offset_y,

mapnik::attributes const& variables,

Napi::Function const& callback)

: AsyncRender(map_obj, callback),

image_(image),

scale_factor_(scale_factor),

scale_denominator_(scale_denominator),

buffer_size_(buffer_size),

offset_x_(offset_x),

offset_y_(offset_y),

variables_(variables) {}

~AsyncRenderImage() {}

void Execute() override

{

try

{

map_ptr map = map_obj_->impl();

mapnik::request request(map->width(), map->height(), map->get_current_extent());

request.set_buffer_size(buffer_size_);

agg_renderer_visitor visit(*map,

request,

variables_,

scale_factor_,

offset_x_,

offset_y_,

scale_denominator_);

mapnik::util::apply_visitor(visit, *image_);

}

catch (std::exception const& ex)

{

SetError(ex.what());

}

}

std::vector<napi_value> GetResult(Napi::Env env) override

{

Napi::Value arg = Napi::External<image_ptr>::New(env, &image_);

Napi::Object obj = Image::constructor.New({arg});

return {env.Null(), napi_value(obj)};

}

private:

image_ptr image_;

double scale_factor_;

double scale_denominator_;

int buffer_size_;

unsigned offset_x_;

unsigned offset_y_;

mapnik::attributes variables_;

{

AsyncRenderGrid(Map* map_obj, grid_ptr const& grid,

double scale_factor, double scale_denominator,

unsigned offset_x, unsigned offset_y,

std::size_t layer_idx,

Napi::Function const& callback)

: AsyncRender(map_obj, callback),

grid_(grid),

scale_factor_(scale_factor),

scale_denominator_(scale_denominator),

offset_x_(offset_x),

offset_y_(offset_y),

layer_idx_(layer_idx) {}

~AsyncRenderGrid() {}

void Execute() override

{

try

{

map_ptr map = map_obj_->impl();

std::vector<mapnik::layer> const& layers = map->layers();

// copy property names

std::set<std::string> attributes = grid_->get_fields();

// todo - make this a static constant

std::string known_id_key = "__id__";

if (attributes.find(known_id_key) != attributes.end())

{

attributes.erase(known_id_key);

}

std::string join_field = grid_->get_key();

if (known_id_key != join_field &&

attributes.find(join_field) == attributes.end())

{

attributes.insert(join_field);

}

mapnik::grid_renderer<mapnik::grid> ren(*map,

*grid_,

scale_factor_,

offset_x_,

offset_y_);

mapnik::layer const& layer = layers[layer_idx_];

ren.apply(layer, attributes, scale_denominator_);

}

catch (std::exception const& ex)

{

SetError(ex.what());

}

}

std::vector<napi_value> GetResult(Napi::Env env) override

{

Napi::Value arg = Napi::External<grid_ptr>::New(env, &grid_);

Napi::Object obj = Grid::constructor.New({arg});

return {env.Null(), napi_value(obj)};

}

private:

grid_ptr grid_;

double scale_factor_;

double scale_denominator_;

unsigned offset_x_;

unsigned offset_y_;

std::size_t layer_idx_;

{

AsyncRenderFile(Map* map_obj, std::string const& output_filename,

double scale_factor, double scale_denominator,

int buffer_size, palette_ptr const& palette,

std::string const& format, bool use_cairo,

mapnik::attributes const& variables,

Napi::Function const& callback)

: AsyncRender(map_obj, callback),

output_filename_(output_filename),

scale_factor_(scale_factor),

scale_denominator_(scale_denominator),

buffer_size_(buffer_size),

palette_(palette),

format_(format),

use_cairo_(use_cairo),

variables_(variables) {}

void Execute() override

{

try

{

map_ptr map = map_obj_->impl();

if (use_cairo_)

{

#if defined(HAVE_CAIRO)

// https://github.com/mapnik/mapnik/issues/1930

mapnik::save_to_cairo_file(*map, output_filename_,

format_, scale_factor_,

scale_denominator_);

#else

SetError("Cairo renderer is not available");

#endif

}

else

{

mapnik::image_rgba8 im(map->width(), map->height());

mapnik::request m_req(map->width(), map->height(), map->get_current_extent());

m_req.set_buffer_size(buffer_size_);

mapnik::agg_renderer<mapnik::image_rgba8> ren(*map,

m_req,

variables_,

im,

scale_factor_);

ren.apply(scale_denominator_);

if (palette_.get())

{

mapnik::save_to_file(im, output_filename_, *palette_);

}

else

{

mapnik::save_to_file(im, output_filename_);

}

}

}

catch (std::exception const& ex)

{

SetError(ex.what());

}

}

std::vector<napi_value> GetResult(Napi::Env env) override

{

return Base::GetResult(env);

}

private:

std::string output_filename_;

double scale_factor_;

double scale_denominator_;

int buffer_size_;

palette_ptr palette_;

std::string format_;

bool use_cairo_;

mapnik::attributes variables_;

{

AsyncRenderVectorTile(Map* map_obj,

mapnik::vector_tile_impl::merc_tile_ptr const& tile,

double area_threshold,

double scale_factor,

double scale_denominator,

unsigned offset_x,

unsigned offset_y,

std::string const& image_format,

mapnik::scaling_method_e scaling_method,

double simplify_distance,

bool strictly_simple,

bool multi_polygon_union,

bool process_all_rings,

mapnik::vector_tile_impl::polygon_fill_type fill_type,

std::launch threading_mode,

mapnik::attributes const& variables,

Napi::Function const& callback)

: AsyncRender(map_obj, callback),

tile_(tile),

area_threshold_(area_threshold),

scale_factor_(scale_factor),

scale_denominator_(scale_denominator),

offset_x_(offset_x),

offset_y_(offset_y),

image_format_(image_format),

scaling_method_(scaling_method),

simplify_distance_(simplify_distance),

strictly_simple_(strictly_simple),

multi_polygon_union_(multi_polygon_union),

process_all_rings_(process_all_rings),

fill_type_(fill_type),

threading_mode_(threading_mode),

variables_(variables) {}

~AsyncRenderVectorTile() {}

void Execute() override

{

try

{

map_ptr map = map_obj_->impl();

mapnik::vector_tile_impl::processor ren(*map, variables_);

ren.set_simplify_distance(simplify_distance_);

ren.set_multi_polygon_union(multi_polygon_union_);

ren.set_fill_type(fill_type_);

ren.set_process_all_rings(process_all_rings_);

ren.set_scale_factor(scale_factor_);

ren.set_strictly_simple(strictly_simple_);

ren.set_image_format(image_format_);

ren.set_scaling_method(scaling_method_);

ren.set_area_threshold(area_threshold_);

ren.set_threading_mode(threading_mode_);

ren.update_tile(*tile_, scale_denominator_, offset_x_, offset_y_);

}

catch (std::exception const& ex)

{

SetError(ex.what());

}

}

std::vector<napi_value> GetResult(Napi::Env env) override

{

Napi::Value arg = Napi::External<mapnik::vector_tile_impl::merc_tile_ptr>::New(env, &tile_);

Napi::Object obj = VectorTile::constructor.New({arg});

return {env.Undefined(), napi_value(obj)};

}

private:

mapnik::vector_tile_impl::merc_tile_ptr tile_;

double area_threshold_;

double scale_factor_;

double scale_denominator_;

unsigned offset_x_;

unsigned offset_y_;

std::string image_format_;

mapnik::scaling_method_e scaling_method_;

double simplify_distance_;

bool strictly_simple_;

bool multi_polygon_union_;

bool process_all_rings_;

mapnik::vector_tile_impl::polygon_fill_type fill_type_;

std::launch threading_mode_;

mapnik::attributes variables_;

{

Napi::Env env = info.Env();

// ensure at least 2 args

if (info.Length() < 2)

{

Napi::TypeError::New(env, "requires at least two arguments, a renderable mapnik object, and a callback")

.ThrowAsJavaScriptException();

return env.Undefined();

}

// ensure renderable object

if (!info[0].IsObject())

{

Napi::TypeError::New(env, "requires a renderable mapnik object to be passed as first argument")

.ThrowAsJavaScriptException();

return env.Undefined();

}

// ensure function callback

if (!info[info.Length() - 1].IsFunction())

{

Napi::TypeError::New(env, "last argument must be a callback function").ThrowAsJavaScriptException();

return env.Undefined();

}

try

{

// parse options

// defaults

int buffer_size = 0;

double scale_factor = 1.0;

double scale_denominator = 0.0;

unsigned offset_x = 0;

unsigned offset_y = 0;

Napi::Object options = Napi::Object::New(env);

if (info.Length() > 2)

{

// options object

if (!info[1].IsObject())

{

Napi::TypeError::New(env, "optional second argument must be an options object").ThrowAsJavaScriptException();

return env.Undefined();

}

options = info[1].As<Napi::Object>();

if (options.Has("buffer_size"))

{

Napi::Value buffer_size_val = options.Get("buffer_size");

if (!buffer_size_val.IsNumber())

{

Napi::TypeError::New(env, "optional arg 'buffer_size' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

buffer_size = buffer_size_val.As<Napi::Number>().Int32Value();

}

if (options.Has("scale"))

{

Napi::Value scale_val = options.Get("scale");

if (!scale_val.IsNumber())

{

Napi::TypeError::New(env, "optional arg 'scale' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

scale_factor = scale_val.As<Napi::Number>().DoubleValue();

}

if (options.Has("scale_denominator"))

{

Napi::Value scale_denominator_val = options.Get("scale_denominator");

if (!scale_denominator_val.IsNumber())

{

Napi::TypeError::New(env, "optional arg 'scale_denominator' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

scale_denominator = scale_denominator_val.As<Napi::Number>().DoubleValue();

}

if (options.Has("offset_x"))

{

Napi::Value offset_x_val = options.Get("offset_x");

if (!offset_x_val.IsNumber())

{

Napi::TypeError::New(env, "optional arg 'offset_x' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

offset_x = offset_x_val.As<Napi::Number>().Uint32Value();

}

if (options.Has("offset_y"))

{

Napi::Value offset_y_val = options.Get("offset_y");

if (!offset_y_val.IsNumber())

{

Napi::TypeError::New(env, "optional arg 'offset_y' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

offset_y = offset_y_val.As<Napi::Number>().Uint32Value();

}

}

Napi::Object obj = info[0].As<Napi::Object>();

if (obj.InstanceOf(Image::constructor.Value()))

{

image_ptr image = Napi::ObjectWrap<Image>::Unwrap(obj)->impl();

mapnik::attributes variables;

if (options.Has("variables"))

{

Napi::Value variables_val = options.Get("variables");

if (!variables_val.IsObject())

{

Napi::TypeError::New(env, "optional arg 'variables' must be an object").ThrowAsJavaScriptException();

return env.Undefined();

}

object_to_container(variables, variables_val.As<Napi::Object>());

}

if (!acquire())

{

Napi::TypeError::New(env, "render: Map currently in use by another thread. Consider using a map pool.").ThrowAsJavaScriptException();

return env.Undefined();

}

Napi::Function callback = info[info.Length() - 1].As<Napi::Function>();

this->Ref();

auto* worker = new detail::AsyncRenderImage{this,

image,

scale_factor,

scale_denominator,

buffer_size,

offset_x,

offset_y,

variables,

callback};

worker->Queue();

return env.Undefined();

}

#if defined(GRID_RENDERER)

else if (obj.InstanceOf(Grid::constructor.Value()))

{

grid_ptr grid = Napi::ObjectWrap<Grid>::Unwrap(obj)->impl();

std::size_t layer_idx = 0;

// grid requires special options for now

if (!options.Has("layer"))

{

Napi::TypeError::New(env, "'layer' option required for grid rendering and must be either a layer name(string) or layer index (integer)").ThrowAsJavaScriptException();

return env.Undefined();

}

else

{

std::vector<mapnik::layer> const& layers = map_->layers();

Napi::Value layer_id = options.Get("layer");

if (!(layer_id.IsString() || layer_id.IsNumber()))

{

Napi::TypeError::New(env, "'layer' option required for grid rendering and must be either a layer name(string) or layer index (integer)").ThrowAsJavaScriptException();

return env.Undefined();

}

if (layer_id.IsString())

{

bool found = false;

unsigned int idx(0);

std::string const& layer_name = layer_id.As<Napi::String>();

for (mapnik::layer const& lyr : layers)

{

if (lyr.name() == layer_name)

{

found = true;

layer_idx = idx;

break;

}

++idx;

}

if (!found)

{

std::ostringstream s;

s << "Layer name '" << layer_name << "' not found";

Napi::TypeError::New(env, s.str()).ThrowAsJavaScriptException();

return env.Undefined();

}

}

else

{ // IS NUMBER

layer_idx = layer_id.As<Napi::Number>().Int32Value();

std::size_t layer_num = layers.size();

if (layer_idx >= layer_num)

{

std::ostringstream s;

s << "Zero-based layer index '" << layer_idx << "' not valid, ";

if (layer_num > 0)

{

s << "only '" << layer_num << "' layers exist in map";

}

else

{

s << "no layers found in map";

}

Napi::TypeError::New(env, s.str().c_str()).ThrowAsJavaScriptException();

return env.Undefined();

}

}

}

if (options.Has("fields"))

{

Napi::Value param_val = options.Get("fields");

if (!param_val.IsArray())

{

Napi::TypeError::New(env, "option 'fields' must be an array of strings").ThrowAsJavaScriptException();

return env.Undefined();

}

Napi::Array a = param_val.As<Napi::Array>();

std::size_t num_fields = a.Length();

for (std::size_t index = 0; index < num_fields; ++index)

{

Napi::Value name = a.Get(index);

if (name.IsString())

{

grid->add_field(name.As<Napi::String>());

}

}

}

if (!acquire())

{

Napi::TypeError::New(env, "render: Map currently in use by another thread. Consider using a map pool.").ThrowAsJavaScriptException();

return env.Undefined();

}

Napi::Function callback = info[info.Length() - 1].As<Napi::Function>();

this->Ref();

auto* worker = new detail::AsyncRenderGrid{this,

grid,

scale_factor,

scale_denominator,

offset_x,

offset_y,

layer_idx,

callback};

worker->Queue();

return env.Undefined();

}

#endif

// VT

else if (obj.InstanceOf(VectorTile::constructor.Value()))

{

mapnik::scaling_method_e scaling_method = mapnik::SCALING_BILINEAR;

std::string image_format = "webp";

double area_threshold = 0.1;

bool strictly_simple = true;

bool multi_polygon_union = false;

mapnik::vector_tile_impl::polygon_fill_type fill_type = mapnik::vector_tile_impl::positive_fill;

std::launch threading_mode = std::launch::deferred;

double simplify_distance = 0.0;

bool process_all_rings = false;

mapnik::attributes variables;

if (options.Has("image_scaling"))

{

Napi::Value param_val = options.Get("image_scaling");

if (!param_val.IsString())

{

Napi::TypeError::New(env, "option 'image_scaling' must be a string").ThrowAsJavaScriptException();

return env.Undefined();

}

std::string image_scaling = param_val.As<Napi::String>();

auto method = mapnik::scaling_method_from_string(image_scaling);

if (!method)

{

Napi::TypeError::New(env, "option 'image_scaling' must be a string and a valid scaling method (e.g 'bilinear')").ThrowAsJavaScriptException();

return env.Undefined();

}

scaling_method = *method;

}

if (options.Has("image_format"))

{

Napi::Value param_val = options.Get("image_format");

if (!param_val.IsString())

{

Napi::TypeError::New(env, "option 'image_format' must be a string").ThrowAsJavaScriptException();

return env.Undefined();

}

image_format = param_val.As<Napi::String>();

}

if (options.Has("area_threshold"))

{

Napi::Value param_val = options.Get("area_threshold");

if (!param_val.IsNumber())

{

Napi::TypeError::New(env, "option 'area_threshold' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

area_threshold = param_val.As<Napi::Number>().DoubleValue();

if (area_threshold < 0.0)

{

Napi::TypeError::New(env, "option 'area_threshold' must not be a negative number").ThrowAsJavaScriptException();

return env.Undefined();

}

}

if (options.Has("strictly_simple"))

{

Napi::Value param_val = options.Get("strictly_simple");

if (!param_val.IsBoolean())

{

Napi::TypeError::New(env, "option 'strictly_simple' must be a boolean").ThrowAsJavaScriptException();

return env.Undefined();

}

strictly_simple = param_val.As<Napi::Boolean>();

}

if (options.Has("multi_polygon_union"))

{

Napi::Value param_val = options.Get("multi_polygon_union");

if (!param_val.IsBoolean())

{

Napi::TypeError::New(env, "option 'multi_polygon_union' must be a boolean").ThrowAsJavaScriptException();

return env.Undefined();

}

multi_polygon_union = param_val.As<Napi::Boolean>();

}

if (options.Has("fill_type"))

{

Napi::Value param_val = options.Get("fill_type");

if (!param_val.IsNumber())

{

Napi::TypeError::New(env, "option 'fill_type' must be an unsigned integer").ThrowAsJavaScriptException();

return env.Undefined();

}

fill_type = static_cast<mapnik::vector_tile_impl::polygon_fill_type>(param_val.As<Napi::Number>().Int32Value());

if (fill_type >= mapnik::vector_tile_impl::polygon_fill_type_max)

{

Napi::TypeError::New(env, "optional arg 'fill_type' out of possible range").ThrowAsJavaScriptException();

return env.Undefined();

}

}

if (options.Has("threading_mode"))

{

Napi::Value param_val = options.Get("threading_mode");

if (!param_val.IsNumber())

{

Napi::TypeError::New(env, "option 'threading_mode' must be an unsigned integer").ThrowAsJavaScriptException();

return env.Undefined();

}

threading_mode = static_cast<std::launch>(param_val.As<Napi::Number>().Int32Value());

if (threading_mode != std::launch::async &&

threading_mode != std::launch::deferred &&

threading_mode != (std::launch::async | std::launch::deferred))

{

Napi::TypeError::New(env, "optional arg 'threading_mode' value passed is invalid").ThrowAsJavaScriptException();

return env.Undefined();

}

}

if (options.Has("simplify_distance"))

{

Napi::Value param_val = options.Get("simplify_distance");

if (!param_val.IsNumber())

{

Napi::TypeError::New(env, "option 'simplify_distance' must be an floating point number").ThrowAsJavaScriptException();

return env.Undefined();

}

simplify_distance = param_val.As<Napi::Number>().DoubleValue();

if (simplify_distance < 0)

{

Napi::TypeError::New(env, "option 'simplify_distance' can not be negative").ThrowAsJavaScriptException();

return env.Undefined();

}

}

if (options.Has("variables"))

{

Napi::Value bind_opt = options.Get("variables");

if (!bind_opt.IsObject())

{

Napi::TypeError::New(env, "optional arg 'variables' must be an object").ThrowAsJavaScriptException();

return env.Undefined();

}

object_to_container(variables, bind_opt.As<Napi::Object>());

}

if (options.Has("process_all_rings"))

{

Napi::Value param_val = options.Get("process_all_rings");

if (!param_val.IsBoolean())

{

Napi::TypeError::New(env, "option 'process_all_rings' must be a boolean").ThrowAsJavaScriptException();

return env.Undefined();

}

process_all_rings = param_val.As<Napi::Boolean>();

}

if (!acquire())

{

Napi::TypeError::New(env, "render: Map currently in use by another thread. Consider using a map pool.").ThrowAsJavaScriptException();

return env.Undefined();

}

Napi::Function callback = info[info.Length() - 1].As<Napi::Function>();

VectorTile* vt = Napi::ObjectWrap<VectorTile>::Unwrap(obj);

if (vt && vt->impl())

{

this->Ref();

auto* worker = new detail::AsyncRenderVectorTile{

this,

vt->impl(),

area_threshold,

scale_factor,

scale_denominator,

offset_x,

offset_y,

image_format,

scaling_method,

simplify_distance,

strictly_simple,

multi_polygon_union,

process_all_rings,

fill_type,

threading_mode,

variables,

callback};

worker->Queue();

}

}

else

{

Napi::TypeError::New(env, "renderable mapnik object expected").ThrowAsJavaScriptException();

}

}

catch (std::exception const& ex)

{

// LCOV_EXCL_START

Napi::TypeError::New(env, ex.what()).ThrowAsJavaScriptException();

// LCOV_EXCL_STOP

}

return env.Undefined();

{

Napi::Env env = info.Env();

Napi::EscapableHandleScope scope(env);

std::string format = "png";

palette_ptr palette;

double scale_factor = 1.0;

double scale_denominator = 0.0;

int buffer_size = 0;

if (info.Length() >= 1)

{

if (!info[0].IsObject())

{

Napi::TypeError::New(env, "first argument is optional, but if provided must be an object, eg. {format: 'pdf'}").ThrowAsJavaScriptException();

return env.Undefined();

}

Napi::Object options = info[0].As<Napi::Object>();

if (options.Has("format"))

{

Napi::Value format_opt = options.Get("format");

if (!format_opt.IsString())

{

Napi::TypeError::New(env, "'format' must be a String").ThrowAsJavaScriptException();

return env.Undefined();

}

format = format_opt.As<Napi::String>();

}

if (options.Has("palette"))

{

Napi::Value palette_opt = options.Get("palette");

if (!palette_opt.IsObject())

{

Napi::TypeError::New(env, "'palette' must be an object").ThrowAsJavaScriptException();

return env.Undefined();

}

Napi::Object obj = palette_opt.As<Napi::Object>();

if (!obj.InstanceOf(Palette::constructor.Value()))

{

Napi::TypeError::New(env, "mapnik.Palette expected as second arg").ThrowAsJavaScriptException();

return env.Undefined();

}

palette = Napi::ObjectWrap<Palette>::Unwrap(obj)->palette_;

}

if (options.Has("buffer_size"))

{

Napi::Value buffer_size_val = options.Get("buffer_size");

if (!buffer_size_val.IsNumber())

{

Napi::TypeError::New(env, "optional arg 'buffer_size' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

buffer_size = buffer_size_val.As<Napi::Number>().Int32Value();

}

if (options.Has("scale"))

{

Napi::Value scale_val = options.Get("scale");

if (!scale_val.IsNumber())

{

Napi::TypeError::New(env, "optional arg 'scale' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

scale_factor = scale_val.As<Napi::Number>().DoubleValue();

}

if (options.Has("scale_denominator"))

{

Napi::Value scale_denominator_val = options.Get("scale_denominator");

if (!scale_denominator_val.IsNumber())

{

Napi::TypeError::New(env, "optional arg 'scale_denominator' must be a number").ThrowAsJavaScriptException();

return env.Undefined();

}

scale_denominator = scale_denominator_val.As<Napi::Number>().DoubleValue();

}

}

if (!acquire())

{

Napi::TypeError::New(env, "render: Map currently in use by another thread. Consider using a map pool.").ThrowAsJavaScriptException();

return env.Undefined();

}

std::string s;

try

{

mapnik::image_rgba8 im(map_->width(), map_->height());

mapnik::request m_req(map_->width(), map_->height(), map_->get_current_extent());

m_req.set_buffer_size(buffer_size);

mapnik::agg_renderer<mapnik::image_rgba8> ren(*map_,

m_req,

mapnik::attributes(),

im,

scale_factor);

ren.apply(scale_denominator);

if (palette.get())

{

s = save_to_string(im, format, *palette);

}

else

{

s = save_to_string(im, format);

}

}

catch (std::exception const& ex)

{