sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Moved image_data_rgba8 to image_rgba8. Ref #2633

Browse source
This commit is contained in:
Blake Thompson 2015-01-21 20:31:02 -06:00
parent e4a5424613
commit 22a384ef33
87 changed files with 252 additions and 252 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
benchmark/compare_images.hpp
View file

@ -24,8 +24,8 @@ namespace benchmark {
throw mapnik::image_reader_exception("Failed to load: " + src_fn);
}
image_data_rgba8 const& dest = util::get<image_data_rgba8>(reader1->read(0,0,reader1->width(), reader1->height()));
image_data_rgba8 const& src = util::get<image_data_rgba8>(reader1->read(0,0,reader1->width(), reader1->height()));
image_rgba8 const& dest = util::get<image_rgba8>(reader1->read(0,0,reader1->width(), reader1->height()));
image_rgba8 const& src = util::get<image_rgba8>(reader1->read(0,0,reader1->width(), reader1->height()));
unsigned int width = src.width();
unsigned int height = src.height();

2
benchmark/test_png_encoding1.cpp
View file

@ -3,7 +3,7 @@
class test : public benchmark::test_case
{
mapnik::image_data_rgba8 im_;
mapnik::image_rgba8 im_;
public:
test(mapnik::parameters const& params)
: test_case(params),

2
benchmark/test_png_encoding2.cpp
View file

@ -3,7 +3,7 @@
class test : public benchmark::test_case
{
std::shared_ptr<image_data_rgba8> im_;
std::shared_ptr<image_rgba8> im_;
public:
test(mapnik::parameters const& params)
: test_case(params) {

2
benchmark/test_polygon_clipping.cpp
View file

@ -36,7 +36,7 @@ void render(mapnik::geometry_type & geom,
using path_type = mapnik::transform_path_adapter<mapnik::view_transform,mapnik::geometry_type>;
using ren_base = agg::renderer_base<agg::pixfmt_rgba32_plain>;
using renderer = agg::renderer_scanline_aa_solid<ren_base>;
mapnik::image_data_rgba8 im(256,256);
mapnik::image_rgba8 im(256,256);
mapnik::fill(im, mapnik::color("white"));
mapnik::box2d<double> padded_extent = extent;
padded_extent.pad(10);

8
benchmark/test_polygon_clipping_rendering.cpp
View file

@ -21,8 +21,8 @@ public:
mapnik::Map m(256,256);
mapnik::load_map(m,xml_);
m.zoom_to_box(extent_);
mapnik::image_data_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m,im);
mapnik::image_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_rgba8> ren(m,im);
ren.apply();
//mapnik::save_to_file(im.data(),"test.png");
return true;
@ -34,8 +34,8 @@ public:
m.zoom_to_box(extent_);
for (unsigned i=0;i<iterations_;++i)
{
mapnik::image_data_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m,im);
mapnik::image_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_rgba8> ren(m,im);
ren.apply();
}
return true;

8
benchmark/test_rendering.cpp
View file

@ -54,8 +54,8 @@ public:
} else {
m.zoom_all();
}
mapnik::image_data_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m,im,scale_factor_);
mapnik::image_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_rgba8> ren(m,im,scale_factor_);
ren.apply();
if (!preview_.empty()) {
std::clog << "preview available at " << preview_ << "\n";
@ -77,8 +77,8 @@ public:
}
for (unsigned i=0;i<iterations_;++i)
{
mapnik::image_data_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m,im,scale_factor_);
mapnik::image_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_rgba8> ren(m,im,scale_factor_);
ren.apply();
}
return true;

12
benchmark/test_rendering_shared_map.cpp
View file

@ -49,7 +49,7 @@ class test : public benchmark::test_case
std::shared_ptr<mapnik::Map> m_;
double scale_factor_;
std::string preview_;
mutable mapnik::image_data_rgba8 im_;
mutable mapnik::image_rgba8 im_;
public:
test(mapnik::parameters const& params)
: test_case(params),
@ -93,7 +93,7 @@ public:
mapnik::projection map_proj(m_->srs(),true);
double scale_denom = mapnik::scale_denominator(m_req.scale(),map_proj.is_geographic());
scale_denom *= scale_factor_;
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(*m_,m_req,variables,im_,scale_factor_);
mapnik::agg_renderer<mapnik::image_rgba8> ren(*m_,m_req,variables,im_,scale_factor_);
ren.start_map_processing(*m_);
std::vector<mapnik::layer> const& layers = m_->layers();
process_layers(ren,m_req,map_proj,layers,scale_denom);
@ -113,20 +113,20 @@ public:
for (unsigned i=0;i<iterations_;++i)
{
mapnik::request m_req(width_,height_,extent_);
mapnik::image_data_rgba8 im(m_->width(),m_->height());
mapnik::image_rgba8 im(m_->width(),m_->height());
mapnik::attributes variables;
m_req.set_buffer_size(m_->buffer_size());
mapnik::projection map_proj(m_->srs(),true);
double scale_denom = mapnik::scale_denominator(m_req.scale(),map_proj.is_geographic());
scale_denom *= scale_factor_;
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(*m_,m_req,variables,im,scale_factor_);
mapnik::agg_renderer<mapnik::image_rgba8> ren(*m_,m_req,variables,im,scale_factor_);
ren.start_map_processing(*m_);
std::vector<mapnik::layer> const& layers = m_->layers();
process_layers(ren,m_req,map_proj,layers,scale_denom);
ren.end_map_processing(*m_);
bool diff = false;
mapnik::image_data_rgba8 const& dest = im;
mapnik::image_data_rgba8 const& src = im_;
mapnik::image_rgba8 const& dest = im;
mapnik::image_rgba8 const& src = im_;
for (unsigned int y = 0; y < height_; ++y)
{
const unsigned int* row_from = src.getRow(y);

2
bindings/python/mapnik_image.cpp
View file

@ -241,7 +241,7 @@ void composite(image_any & dst, image_any & src, mapnik::composite_mode_e mode,
std::shared_ptr<image_any> from_cairo(PycairoSurface* py_surface)
{
mapnik::cairo_surface_ptr surface(cairo_surface_reference(py_surface->surface), mapnik::cairo_surface_closer());
mapnik::image_data_rgba8 image = mapnik::image_data_rgba8(cairo_image_surface_get_width(&*surface), cairo_image_surface_get_height(&*surface));
mapnik::image_rgba8 image = mapnik::image_rgba8(cairo_image_surface_get_width(&*surface), cairo_image_surface_get_height(&*surface));
cairo_image_to_rgba8(image, surface);
return std::make_shared<image_any>(std::move(image));
}

16
bindings/python/mapnik_python.cpp
View file

@ -208,9 +208,9 @@ struct agg_renderer_visitor_1
};
template <>
void agg_renderer_visitor_1::operator()<mapnik::image_data_rgba8> (mapnik::image_data_rgba8 & pixmap)
void agg_renderer_visitor_1::operator()<mapnik::image_rgba8> (mapnik::image_rgba8 & pixmap)
{
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m_,pixmap,scale_factor_,offset_x_, offset_y_);
mapnik::agg_renderer<mapnik::image_rgba8> ren(m_,pixmap,scale_factor_,offset_x_, offset_y_);
ren.apply();
}
@ -235,9 +235,9 @@ struct agg_renderer_visitor_2
};
template <>
void agg_renderer_visitor_2::operator()<mapnik::image_data_rgba8> (mapnik::image_data_rgba8 & pixmap)
void agg_renderer_visitor_2::operator()<mapnik::image_rgba8> (mapnik::image_rgba8 & pixmap)
{
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m_,pixmap,detector_, scale_factor_,offset_x_, offset_y_);
mapnik::agg_renderer<mapnik::image_rgba8> ren(m_,pixmap,detector_, scale_factor_,offset_x_, offset_y_);
ren.apply();
}
@ -264,9 +264,9 @@ struct agg_renderer_visitor_3
};
template <>
void agg_renderer_visitor_3::operator()<mapnik::image_data_rgba8> (mapnik::image_data_rgba8 & pixmap)
void agg_renderer_visitor_3::operator()<mapnik::image_rgba8> (mapnik::image_rgba8 & pixmap)
{
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m_,req_, vars_, pixmap, scale_factor_, offset_x_, offset_y_);
mapnik::agg_renderer<mapnik::image_rgba8> ren(m_,req_, vars_, pixmap, scale_factor_, offset_x_, offset_y_);
ren.apply();
}
@ -293,9 +293,9 @@ struct agg_renderer_visitor_4
};
template <>
void agg_renderer_visitor_4::operator()<mapnik::image_data_rgba8> (mapnik::image_data_rgba8 & pixmap)
void agg_renderer_visitor_4::operator()<mapnik::image_rgba8> (mapnik::image_rgba8 & pixmap)
{
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m_,pixmap,scale_factor_,offset_x_, offset_y_);
mapnik::agg_renderer<mapnik::image_rgba8> ren(m_,pixmap,scale_factor_,offset_x_, offset_y_);
ren.apply(layer_, names_);
}

6
demo/c++/rundemo.cpp
View file

@ -305,8 +305,8 @@ int main ( int, char** )
m.zoom_to_box(box2d<double>(-8024477.28459,5445190.38849,-7381388.20071,5662941.44855));
image_data_rgba8 buf(m.width(),m.height());
agg_renderer<image_data_rgba8> ren(m,buf);
image_rgba8 buf(m.width(),m.height());
agg_renderer<image_rgba8> ren(m,buf);
ren.apply();
std::string msg("These maps have been rendered using AGG in the current directory:\n");
#ifdef HAVE_JPEG
@ -353,7 +353,7 @@ int main ( int, char** )
cairo_surface_write_to_png(&*image_surface, "cairo-demo.png");
// but we can also benefit from quantization by converting
// to a mapnik image object and then saving that
mapnik::image_data_rgba8 im_data(cairo_image_surface_get_width(&*image_surface), cairo_image_surface_get_height(&*image_surface));
mapnik::image_rgba8 im_data(cairo_image_surface_get_width(&*image_surface), cairo_image_surface_get_height(&*image_surface));
cairo_image_to_rgba8(im_data, image_surface);
save_to_file(im_data, "cairo-demo256.png","png8");
cairo_surface_finish(&*image_surface);

10
demo/viewer/mapwidget.cpp
View file

@ -41,7 +41,7 @@
#include "mapwidget.hpp"
#include "info_dialog.hpp"
using mapnik::image_data_rgba8;
using mapnik::image_rgba8;
using mapnik::Map;
using mapnik::layer;
using mapnik::box2d;
@ -478,7 +478,7 @@ void MapWidget::zoomToLevel(int level)
void MapWidget::export_to_file(unsigned ,unsigned ,std::string const&,std::string const&)
{
//image_data_rgba8 image(width,height);
//image_rgba8 image(width,height);
//agg_renderer renderer(map,image);
//renderer.apply();
//image.saveToFile(filename,type);
@ -495,8 +495,8 @@ void render_agg(mapnik::Map const& map, double scaling_factor, QPixmap & pix)
unsigned width=map.width();
unsigned height=map.height();
image_data_rgba8 buf(width,height);
mapnik::agg_renderer<image_data_rgba8> ren(map,buf,scaling_factor);
image_rgba8 buf(width,height);
mapnik::agg_renderer<image_rgba8> ren(map,buf,scaling_factor);
try
{
@ -539,7 +539,7 @@ void render_cairo(mapnik::Map const& map, double scaling_factor, QPixmap & pix)
mapnik::cairo_renderer<mapnik::cairo_ptr> renderer(map, cairo, scaling_factor);
renderer.apply();
}
mapnik::image_data_rgba8 data(map.width(), map.height());
mapnik::image_rgba8 data(map.width(), map.height());
mapnik::cairo_image_to_rgba8(data, image_surface);
QImage image((uchar*)data.getBytes(),data.width(),data.height(),QImage::Format_ARGB32);
pix = QPixmap::fromImage(image.rgbSwapped());

2
demo/viewer/styles_model.cpp
View file

@ -201,7 +201,7 @@ struct symbolizer_icon
{
// FIXME!
/*
std::shared_ptr<mapnik::image_data_rgba8> symbol = sym.get_image();
std::shared_ptr<mapnik::image_rgba8> symbol = sym.get_image();
if (symbol)
{
QImage image(symbol->getBytes(),

4
include/mapnik/agg_pattern_source.hpp
View file

@ -36,7 +36,7 @@ namespace mapnik
class pattern_source : private util::noncopyable
{
public:
pattern_source(image_data_rgba8 const& pattern, double opacity = 1.0)
pattern_source(image_rgba8 const& pattern, double opacity = 1.0)
: pattern_(pattern),
opacity_(opacity) {}
@ -57,7 +57,7 @@ public:
static_cast<unsigned>(((c >> 24) & 0xff) * opacity_));
}
private:
image_data_rgba8 const& pattern_;
image_rgba8 const& pattern_;
double opacity_;
};
}

2
include/mapnik/agg_render_marker.hpp
View file

@ -66,7 +66,7 @@ void render_vector_marker(SvgRenderer & svg_renderer, RasterizerType & ras, Rend
}
template <typename RendererType, typename RasterizerType>
void render_raster_marker(RendererType renb, RasterizerType & ras, image_data_rgba8 const& src,
void render_raster_marker(RendererType renb, RasterizerType & ras, image_rgba8 const& src,
agg::trans_affine const& tr, double opacity,
float scale_factor, bool snap_to_pixels)
{

2
include/mapnik/agg_renderer.hpp
View file

@ -171,7 +171,7 @@ private:
void setup(Map const& m);
};
extern template class MAPNIK_DECL agg_renderer<image_data_rgba8>;
extern template class MAPNIK_DECL agg_renderer<image_rgba8>;
} // namespace mapnik

6
include/mapnik/cairo/cairo_context.hpp
View file

@ -122,7 +122,7 @@ private:
class cairo_pattern : private util::noncopyable
{
public:
explicit cairo_pattern(image_data_rgba8 const& data, double opacity = 1.0)
explicit cairo_pattern(image_rgba8 const& data, double opacity = 1.0)
{
int pixels = data.width() * data.height();
const unsigned int *in_ptr = data.getData();
@ -310,8 +310,8 @@ public:
void set_gradient(cairo_gradient const& pattern, box2d<double> const& bbox);
void add_image(double x, double y, image_any & data, double opacity);
void add_image(agg::trans_affine const& tr, image_any & data, double opacity);
void add_image(double x, double y, image_data_rgba8 & data, double opacity = 1.0);
void add_image(agg::trans_affine const& tr, image_data_rgba8 & data, double opacity = 1.0);
void add_image(double x, double y, image_rgba8 & data, double opacity = 1.0);
void add_image(agg::trans_affine const& tr, image_rgba8 & data, double opacity = 1.0);
void set_font_face(cairo_face_manager & manager, face_ptr face);
void set_font_matrix(cairo_matrix_t const& matrix);
void set_matrix(cairo_matrix_t const& matrix);

2
include/mapnik/cairo/cairo_image_util.hpp
View file

@ -33,7 +33,7 @@
namespace mapnik {
static inline void cairo_image_to_rgba8(mapnik::image_data_rgba8 & data,
static inline void cairo_image_to_rgba8(mapnik::image_rgba8 & data,
cairo_surface_ptr const& surface)
{
if (cairo_image_surface_get_format(&*surface) != CAIRO_FORMAT_ARGB32)

2
include/mapnik/grid/grid.hpp
View file

@ -195,7 +195,7 @@ public:
return height_;
}
inline void set_rectangle(value_type id,image_data_rgba8 const& data,int x0,int y0)
inline void set_rectangle(value_type id,image_rgba8 const& data,int x0,int y0)
{
box2d<int> ext0(0,0,width_,height_);
box2d<int> ext1(x0,y0,x0+data.width(),y0+data.height());

4
include/mapnik/grid/grid_marker_helpers.hpp
View file

@ -51,7 +51,7 @@ struct raster_markers_rasterizer_dispatch_grid : util::noncopyable
using RasterizerType = typename std::tuple_element<1,RendererContext>::type;
using PixMapType = typename std::tuple_element<2,RendererContext>::type;
raster_markers_rasterizer_dispatch_grid(image_data_rgba8 const& src,
raster_markers_rasterizer_dispatch_grid(image_rgba8 const& src,
agg::trans_affine const& marker_trans,
markers_symbolizer const& sym,
Detector & detector,
@ -130,7 +130,7 @@ private:
pixfmt_type pixf_;
RendererBase renb_;
RasterizerType & ras_;
image_data_rgba8 const& src_;
image_rgba8 const& src_;
agg::trans_affine const& marker_trans_;
markers_symbolizer const& sym_;
Detector & detector_;

2
include/mapnik/grid/grid_render_marker.hpp
View file

@ -41,7 +41,7 @@ namespace mapnik {
template <typename RendererType, typename RasterizerType>
void render_raster_marker(RendererType ren,
RasterizerType & ras,
image_data_rgba8 & src,
image_rgba8 & src,
mapnik::feature_impl const& feature,
agg::trans_affine const& marker_tr,
double opacity)

4
include/mapnik/image_any.hpp
View file

@ -52,7 +52,7 @@ struct image_data_null
};
using image_data_base = util::variant<image_data_null,
image_data_rgba8,
image_rgba8,
image_data_gray8,
image_data_gray16,
image_data_gray32f>;
@ -217,7 +217,7 @@ inline image_any create_image_any(int width,
return image_any(std::move(image_data_null()));
case image_dtype_rgba8:
default:
return image_any(std::move(image_data_rgba8(width, height, initialize, premultiplied, painted)));
return image_any(std::move(image_rgba8(width, height, initialize, premultiplied, painted)));
}
}

2
include/mapnik/image_data.hpp
View file

@ -277,7 +277,7 @@ private:
bool painted_;
};
using image_data_rgba8 = image_data<std::uint32_t>;
using image_rgba8 = image_data<std::uint32_t>;
using image_data_gray8 = image_data<std::uint8_t> ;
using image_data_gray16 = image_data<std::int16_t>;
using image_data_gray32f = image_data<float>;

2
include/mapnik/image_reader.hpp
View file

@ -60,7 +60,7 @@ struct MAPNIK_DECL image_reader : private util::noncopyable
virtual unsigned height() const = 0;
virtual bool has_alpha() const = 0;
virtual boost::optional<box2d<double> > bounding_box() const = 0;
virtual void read(unsigned x,unsigned y,image_data_rgba8& image) = 0;
virtual void read(unsigned x,unsigned y,image_rgba8& image) = 0;
virtual image_any read(unsigned x, unsigned y, unsigned width, unsigned height) = 0;
virtual ~image_reader() {}
};

2
include/mapnik/image_scaling_traits.hpp
View file

@ -38,7 +38,7 @@ template <typename T>
struct agg_scaling_traits {};
template <>
struct agg_scaling_traits<image_data_rgba8>
struct agg_scaling_traits<image_rgba8>
{
using pixfmt_pre = agg::pixfmt_rgba32_pre;
using color_type = agg::rgba8;

20
include/mapnik/image_util.hpp
View file

@ -233,7 +233,7 @@ void add_border(T & image)
}
/*
extern template MAPNIK_DECL void save_to_file<image_data_rgba8>(image_data_rgba8 const&,
extern template MAPNIK_DECL void save_to_file<image_rgba8>(image_rgba8 const&,
std::string const&,
std::string const&,
rgba_palette const&);
@ -243,7 +243,7 @@ extern template MAPNIK_DECL void save_to_file<image_any>(image_any const&,
std::string const&,
rgba_palette const&);
extern template MAPNIK_DECL void save_to_file<image_data_rgba8>(image_data_rgba8 const&,
extern template MAPNIK_DECL void save_to_file<image_rgba8>(image_rgba8 const&,
std::string const&,
std::string const&);
@ -251,7 +251,7 @@ extern template MAPNIK_DECL void save_to_file<image_any>(image_any const&,
std::string const&,
std::string const&);
extern template MAPNIK_DECL void save_to_file<image_data_rgba8>(image_data_rgba8 const&,
extern template MAPNIK_DECL void save_to_file<image_rgba8>(image_rgba8 const&,
std::string const&,
rgba_palette const&);
@ -259,7 +259,7 @@ extern template MAPNIK_DECL void save_to_file<image_any>(image_any const&,
std::string const&,
rgba_palette const&);
extern template MAPNIK_DECL void save_to_file<image_data_rgba8>(image_data_rgba8 const&,
extern template MAPNIK_DECL void save_to_file<image_rgba8>(image_rgba8 const&,
std::string const&);
extern template MAPNIK_DECL void save_to_file<image_any>(image_any const&,
@ -281,10 +281,10 @@ extern template MAPNIK_DECL void save_to_file<image_view_any>(image_view_any con
extern template MAPNIK_DECL void save_to_file<image_view_any>(image_view_any const&,
std::string const&);
extern template MAPNIK_DECL std::string save_to_string<image_data_rgba8>(image_data_rgba8 const&,
extern template MAPNIK_DECL std::string save_to_string<image_rgba8>(image_rgba8 const&,
std::string const&);
extern template MAPNIK_DECL std::string save_to_string<image_data_rgba8>(image_data_rgba8 const&,
extern template MAPNIK_DECL std::string save_to_string<image_rgba8>(image_rgba8 const&,
std::string const&,
rgba_palette const&);
@ -311,15 +311,15 @@ extern template MAPNIK_DECL std::string save_to_string<image_view_any> (image_vi
*/
#ifdef _MSC_VER
template MAPNIK_DECL void save_to_stream<image_data_rgba8>(
image_data_rgba8 const& image,
template MAPNIK_DECL void save_to_stream<image_rgba8>(
image_rgba8 const& image,
std::ostream & stream,
std::string const& type,
rgba_palette const& palette
);
template MAPNIK_DECL void save_to_stream<image_data_rgba8>(
image_data_rgba8 const& image,
template MAPNIK_DECL void save_to_stream<image_rgba8>(
image_rgba8 const& image,
std::ostream & stream,
std::string const& type
);

2
include/mapnik/image_view.hpp
View file

@ -118,7 +118,7 @@ private:
T const& data_;
};
using image_view_rgba8 = image_view<image_data_rgba8>;
using image_view_rgba8 = image_view<image_rgba8>;
using image_view_gray8 = image_view<image_data_gray8>;
using image_view_gray16 = image_view<image_data_gray16>;
using image_view_gray32f = image_view<image_data_gray32f>;

2
include/mapnik/marker.hpp
View file

@ -57,7 +57,7 @@ public:
marker()
{
// create default OGC 4x4 black pixel
image_data_rgba8 image(4,4,true,true);
image_rgba8 image(4,4,true,true);
image.set(0xff000000);
bitmap_data_ = boost::optional<image_ptr>(std::make_shared<image_any>(std::move(image)));
}

4
include/mapnik/miniz_png.hpp
View file

@ -85,9 +85,9 @@ private:
extern template MAPNIK_DECL void PNGWriter::writeIDAT<image_data_gray8>(image_data_gray8 const& image);
extern template MAPNIK_DECL void PNGWriter::writeIDAT<image_view_gray8>(image_view_gray8 const& image);
extern template MAPNIK_DECL void PNGWriter::writeIDAT<image_data_rgba8>(image_data_rgba8 const& image);
extern template MAPNIK_DECL void PNGWriter::writeIDAT<image_rgba8>(image_rgba8 const& image);
extern template MAPNIK_DECL void PNGWriter::writeIDAT<image_view_rgba8>(image_view_rgba8 const& image);
extern template MAPNIK_DECL void PNGWriter::writeIDATStripAlpha<image_data_rgba8>(image_data_rgba8 const& image);
extern template MAPNIK_DECL void PNGWriter::writeIDATStripAlpha<image_rgba8>(image_rgba8 const& image);
extern template MAPNIK_DECL void PNGWriter::writeIDATStripAlpha<image_view_rgba8>(image_view_rgba8 const& image);
}}

8
include/mapnik/png_io.hpp
View file

@ -166,7 +166,7 @@ void reduce_8(T const& in,
}
for (unsigned y = 0; y < height; ++y)
{
mapnik::image_data_rgba8::pixel_type const * row = in.getRow(y);
mapnik::image_rgba8::pixel_type const * row = in.getRow(y);
mapnik::image_data_gray8::pixel_type * row_out = out.getRow(y);
for (unsigned x = 0; x < width; ++x)
{
@ -217,7 +217,7 @@ void reduce_4(T const& in,
}
for (unsigned y = 0; y < height; ++y)
{
mapnik::image_data_rgba8::pixel_type const * row = in.getRow(y);
mapnik::image_rgba8::pixel_type const * row = in.getRow(y);
mapnik::image_data_gray8::pixel_type * row_out = out.getRow(y);
for (unsigned x = 0; x < width; ++x)
{
@ -603,7 +603,7 @@ void save_as_png8(T1 & file,
image_data_gray8 reduced_image(width, height);
for (unsigned y = 0; y < height; ++y)
{
mapnik::image_data_rgba8::pixel_type const * row = image.getRow(y);
mapnik::image_rgba8::pixel_type const * row = image.getRow(y);
mapnik::image_data_gray8::pixel_type * row_out = reduced_image.getRow(y);
for (unsigned x = 0; x < width; ++x)
{
@ -629,7 +629,7 @@ void save_as_png8(T1 & file,
image_data_gray8 reduced_image(image_width, image_height);
for (unsigned y = 0; y < height; ++y)
{
mapnik::image_data_rgba8::pixel_type const * row = image.getRow(y);
mapnik::image_rgba8::pixel_type const * row = image.getRow(y);
mapnik::image_data_gray8::pixel_type * row_out = reduced_image.getRow(y);
byte index = 0;
for (unsigned x = 0; x < width; ++x)

2
include/mapnik/raster_colorizer.hpp
View file

@ -198,7 +198,7 @@ public:
colorizer_stops const& get_stops() const { return stops_; }
template <typename T>
void colorize(image_data_rgba8 & out, T const& in, boost::optional<double>const& nodata, feature_impl const& f) const;
void colorize(image_rgba8 & out, T const& in, boost::optional<double>const& nodata, feature_impl const& f) const;
//! \brief Perform the translation of input to output
//!

4
include/mapnik/renderer_common/process_group_symbolizer.hpp
View file

@ -150,7 +150,7 @@ struct raster_marker_render_thunk : util::noncopyable
snap_to_pixels_(std::move(rhs.snap_to_pixels_)) {}
};
template struct raster_marker_render_thunk<image_data_rgba8>;
template struct raster_marker_render_thunk<image_rgba8>;
template struct raster_marker_render_thunk<image_data_gray8>;
template struct raster_marker_render_thunk<image_data_gray16>;
template struct raster_marker_render_thunk<image_data_gray32f>;
@ -184,7 +184,7 @@ struct text_render_thunk : util::noncopyable
// via a static visitor later.
using render_thunk = util::variant<vector_marker_render_thunk,
raster_marker_render_thunk<image_data_rgba8>,
raster_marker_render_thunk<image_rgba8>,
raster_marker_render_thunk<image_data_gray8>,
raster_marker_render_thunk<image_data_gray16>,
raster_marker_render_thunk<image_data_gray32f>,

18
include/mapnik/renderer_common/process_raster_symbolizer.hpp
View file

@ -70,9 +70,9 @@ struct image_data_dispatcher
nodata_(nodata) {}
void operator() (image_data_null const& data_in) const {} //no-op
void operator() (image_data_rgba8 const& data_in) const
void operator() (image_rgba8 const& data_in) const
{
image_data_rgba8 data_out(width_, height_, true, true);
image_rgba8 data_out(width_, height_, true, true);
scale_image_agg(data_out, data_in, method_, scale_x_, scale_y_, 0.0, 0.0, filter_factor_);
composite_(data_out, comp_op_, opacity_, start_x_, start_y_);
}
@ -83,7 +83,7 @@ struct image_data_dispatcher
using image_data_type = T;
image_data_type data_out(width_, height_);
scale_image_agg(data_out, data_in, method_, scale_x_, scale_y_, 0.0, 0.0, filter_factor_);
image_data_rgba8 dst(width_, height_);
image_rgba8 dst(width_, height_);
raster_colorizer_ptr colorizer = get<raster_colorizer_ptr>(sym_, keys::colorizer);
if (colorizer) colorizer->colorize(dst, data_out, nodata_, feature_);
premultiply_alpha(dst);
@ -137,9 +137,9 @@ struct image_data_warp_dispatcher
void operator() (image_data_null const& data_in) const {} //no-op
void operator() (image_data_rgba8 const& data_in) const
void operator() (image_rgba8 const& data_in) const
{
image_data_rgba8 data_out(width_, height_, true, true);
image_rgba8 data_out(width_, height_, true, true);
warp_image(data_out, data_in, prj_trans_, target_ext_, source_ext_, offset_x_, offset_y_, mesh_size_, scaling_method_, filter_factor_);
composite_(data_out, comp_op_, opacity_, start_x_, start_y_);
}
@ -151,7 +151,7 @@ struct image_data_warp_dispatcher
image_data_type data_out(width_, height_);
if (nodata_) data_out.set(*nodata_);
warp_image(data_out, data_in, prj_trans_, target_ext_, source_ext_, offset_x_, offset_y_, mesh_size_, scaling_method_, filter_factor_);
image_data_rgba8 dst(width_, height_);
image_rgba8 dst(width_, height_);
raster_colorizer_ptr colorizer = get<raster_colorizer_ptr>(sym_, keys::colorizer);
if (colorizer) colorizer->colorize(dst, data_out, nodata_, feature_);
premultiply_alpha(dst);
@ -205,7 +205,7 @@ void render_raster_symbolizer(raster_symbolizer const& sym,
composite_mode_e comp_op = get<composite_mode_e>(sym, keys::comp_op, feature, common.vars_, src_over);
double opacity = get<double>(sym,keys::opacity,feature, common.vars_, 1.0);
// only premultiply rgba8 images
if (source->data_.is<image_data_rgba8>())
if (source->data_.is<image_rgba8>())
{
auto is_premultiplied = get_optional<bool>(sym, keys::premultiplied, feature, common.vars_);
if (is_premultiplied && *is_premultiplied)
@ -236,9 +236,9 @@ void render_raster_symbolizer(raster_symbolizer const& sym,
(std::abs(start_x) <= eps) &&
(std::abs(start_y) <= eps) )
{
if (source->data_.is<image_data_rgba8>())
if (source->data_.is<image_rgba8>())
{
composite(util::get<image_data_rgba8>(source->data_), comp_op, opacity, start_x, start_y);
composite(util::get<image_rgba8>(source->data_), comp_op, opacity, start_x, start_y);
}
}
else

2
include/mapnik/tiff_io.hpp
View file

@ -192,7 +192,7 @@ struct tag_setter
throw ImageWriterException("Could not write TIFF - unknown image type provided");
}
inline void operator() (image_data_rgba8 const& data) const
inline void operator() (image_rgba8 const& data) const
{
TIFFSetField(output_, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
TIFFSetField(output_, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);

8
include/mapnik/webp_io.hpp
View file

@ -98,11 +98,11 @@ inline int import_image_data(T2 const& image,
else
{
// need to copy: https://github.com/mapnik/mapnik/issues/2024
image_data_rgba8 im(image.width(),image.height());
image_rgba8 im(image.width(),image.height());
for (unsigned y = 0; y < image.height(); ++y)
{
typename T2::pixel_type const * row_from = image.getRow(y);
image_data_rgba8::pixel_type * row_to = im.getRow(y);
image_rgba8::pixel_type * row_to = im.getRow(y);
std::copy(row_from, row_from + stride, row_to);
}
if (alpha)
@ -121,11 +121,11 @@ inline int import_image_data(T2 const& image,
}
template <>
inline int import_image_data(image_data_rgba8 const& im,
inline int import_image_data(image_rgba8 const& im,
WebPPicture & pic,
bool alpha)
{
int stride = sizeof(image_data_rgba8::pixel_type) * im.width();
int stride = sizeof(image_rgba8::pixel_type) * im.width();
if (alpha)
{
return WebPPictureImportRGBA(&pic, im.getBytes(), stride);

2
plugins/input/gdal/gdal_featureset.cpp
View file

@ -229,7 +229,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
}
else // working with all bands
{
mapnik::image_data_rgba8 image(im_width, im_height);
mapnik::image_rgba8 image(im_width, im_height);
image.set(std::numeric_limits<std::uint32_t>::max());
for (int i = 0; i < nbands_; ++i)
{

4
plugins/input/pgraster/pgraster_wkb_reader.cpp
View file

@ -271,7 +271,7 @@ mapnik::raster_ptr read_grayscale_band(mapnik::box2d<double> const& bbox,
uint16_t width, uint16_t height,
bool hasnodata, T reader)
{
mapnik::image_data_rgba8 image(width,height, true, true);
mapnik::image_rgba8 image(width,height, true, true);
// Start with plain white (ABGR or RGBA depending on endiannes)
// TODO: set to transparent instead?
image.set(0xffffffff);
@ -352,7 +352,7 @@ mapnik::raster_ptr pgraster_wkb_reader::read_grayscale(mapnik::box2d<double> con
mapnik::raster_ptr pgraster_wkb_reader::read_rgba(mapnik::box2d<double> const& bbox,
uint16_t width, uint16_t height)
{
mapnik::image_data_rgba8 image(width, height, true, true);
mapnik::image_rgba8 image(width, height, true, true);
// Start with plain white (ABGR or RGBA depending on endiannes)
image.set(0xffffffff);

2
plugins/input/raster/raster_featureset.cpp
View file

@ -43,7 +43,7 @@
using mapnik::query;
using mapnik::image_reader;
using mapnik::feature_ptr;
using mapnik::image_data_rgba8;
using mapnik::image_rgba8;
using mapnik::raster;
using mapnik::feature_factory;

2
plugins/input/rasterlite/rasterlite_featureset.cpp
View file

@ -114,7 +114,7 @@ feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
{
if (size > 0)
{
mapnik::image_data_rgba8 image(width,height);
mapnik::image_rgba8 image(width,height);
unsigned char* raster_data = static_cast<unsigned char*>(raster);
unsigned char* image_data = image.getBytes();
std::memcpy(image_data, raster_data, size);

4
src/agg/agg_renderer.cpp
View file

@ -517,8 +517,8 @@ void agg_renderer<T0,T1>::draw_geo_extent(box2d<double> const& extent, mapnik::c
}
}
template class agg_renderer<image_data_rgba8>;
template void agg_renderer<image_data_rgba8>::debug_draw_box<agg::rendering_buffer>(
template class agg_renderer<image_rgba8>;
template void agg_renderer<image_rgba8>::debug_draw_box<agg::rendering_buffer>(
agg::rendering_buffer& buf,
box2d<double> const& box,
double x, double y, double angle);

2
src/agg/process_building_symbolizer.cpp
View file

@ -109,7 +109,7 @@ void agg_renderer<T0,T1>::process(building_symbolizer const& sym,
});
}
template void agg_renderer<image_data_rgba8>::process(building_symbolizer const&,
template void agg_renderer<image_rgba8>::process(building_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);
}

2
src/agg/process_debug_symbolizer.cpp
View file

@ -91,7 +91,7 @@ void agg_renderer<T0,T1>::process(debug_symbolizer const& sym,
}
}
template void agg_renderer<image_data_rgba8>::process(debug_symbolizer const&,
template void agg_renderer<image_rgba8>::process(debug_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);
}

2
src/agg/process_dot_symbolizer.cpp
View file

@ -98,7 +98,7 @@ void agg_renderer<T0,T1>::process(dot_symbolizer const& sym,
}
}
template void agg_renderer<image_data_rgba8>::process(dot_symbolizer const&,
template void agg_renderer<image_rgba8>::process(dot_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

14
src/agg/process_group_symbolizer.cpp
View file

@ -54,9 +54,9 @@ template <typename T>
struct thunk_renderer;
template <>
struct thunk_renderer<image_data_rgba8>
struct thunk_renderer<image_rgba8>
{
using renderer_type = agg_renderer<image_data_rgba8>;
using renderer_type = agg_renderer<image_rgba8>;
using buffer_type = renderer_type::buffer_type;
using text_renderer_type = agg_text_renderer<buffer_type>;
@ -94,7 +94,7 @@ struct thunk_renderer<image_data_rgba8>
render_vector_marker(svg_renderer, *ras_ptr_, renb, thunk.src_->bounding_box(), offset_tr, thunk.opacity_, thunk.snap_to_pixels_);
}
void operator()(raster_marker_render_thunk<image_data_rgba8> const &thunk) const
void operator()(raster_marker_render_thunk<image_rgba8> const &thunk) const
{
using blender_type = agg::comp_op_adaptor_rgba_pre<agg::rgba8, agg::order_rgba>; // comp blender
using buf_type = agg::rendering_buffer;
@ -114,17 +114,17 @@ struct thunk_renderer<image_data_rgba8>
void operator()(raster_marker_render_thunk<image_data_gray8> const &thunk) const
{
throw std::runtime_error("Rendering of this image_data_gray8 type is not supported currently by the image_data_rgba8 renderer");
throw std::runtime_error("Rendering of this image_data_gray8 type is not supported currently by the image_rgba8 renderer");
}
void operator()(raster_marker_render_thunk<image_data_gray16> const &thunk) const
{
throw std::runtime_error("Rendering of this image_data_gray16 type is not supported currently by the image_data_rgba8 renderer");
throw std::runtime_error("Rendering of this image_data_gray16 type is not supported currently by the image_rgba8 renderer");
}
void operator()(raster_marker_render_thunk<image_data_gray32f> const &thunk) const
{
throw std::runtime_error("Rendering of this image_data_gray32f type is not supported currently by the image_data_rgba8 renderer");
throw std::runtime_error("Rendering of this image_data_gray32f type is not supported currently by the image_rgba8 renderer");
}
void operator()(text_render_thunk const &thunk) const
@ -179,7 +179,7 @@ void agg_renderer<T0,T1>::process(group_symbolizer const& sym,
});
}
template void agg_renderer<image_data_rgba8>::process(group_symbolizer const&,
template void agg_renderer<image_rgba8>::process(group_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

6
src/agg/process_line_pattern_symbolizer.cpp
View file

@ -78,12 +78,12 @@ void agg_renderer<T0,T1>::process(line_pattern_symbolizer const& sym,
if ((*marker_ptr)->is_bitmap())
{
// FIXME: copy is necessary atm to transform a
// shared_ptr<image_any> into shared_ptr<image_data_rgba8>
// shared_ptr<image_any> into shared_ptr<image_rgba8>
boost::optional<image_ptr> bitmap = (*marker_ptr)->get_bitmap_data();
if (bitmap) {
mapnik::image_any const& im = *(bitmap)->get();
if (im.is<buffer_type>()) {
// invoke copy ctor of image_data_rgba8
// invoke copy ctor of image_rgba8
pat = std::make_shared<buffer_type>(util::get<buffer_type>(im));
}
}
@ -153,7 +153,7 @@ void agg_renderer<T0,T1>::process(line_pattern_symbolizer const& sym,
}
}
template void agg_renderer<image_data_rgba8>::process(line_pattern_symbolizer const&,
template void agg_renderer<image_rgba8>::process(line_pattern_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

2
src/agg/process_line_symbolizer.cpp
View file

@ -223,7 +223,7 @@ void agg_renderer<T0,T1>::process(line_symbolizer const& sym,
}
template void agg_renderer<image_data_rgba8>::process(line_symbolizer const&,
template void agg_renderer<image_rgba8>::process(line_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

4
src/agg/process_markers_symbolizer.cpp
View file

@ -149,7 +149,7 @@ struct raster_markers_rasterizer_dispatch : public raster_markers_dispatch<Detec
{
// In the long term this should be a visitor pattern based on the type of render this->src_ provided that converts
// the destination pixel type required.
render_raster_marker(renb_, ras_, util::get<image_data_rgba8>(this->src_), marker_tr, opacity, this->scale_factor_, snap_to_pixels_);
render_raster_marker(renb_, ras_, util::get<image_rgba8>(this->src_), marker_tr, opacity, this->scale_factor_, snap_to_pixels_);
}
private:
@ -204,7 +204,7 @@ void agg_renderer<T0,T1>::process(markers_symbolizer const& sym,
sym, feature, prj_trans, common_, clip_box, renderer_context);
}
template void agg_renderer<image_data_rgba8>::process(markers_symbolizer const&,
template void agg_renderer<image_rgba8>::process(markers_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);
}

2
src/agg/process_point_symbolizer.cpp
View file

@ -60,7 +60,7 @@ void agg_renderer<T0,T1>::process(point_symbolizer const& sym,
});
}
template void agg_renderer<image_data_rgba8>::process(point_symbolizer const&,
template void agg_renderer<image_rgba8>::process(point_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

6
src/agg/process_polygon_pattern_symbolizer.cpp
View file

@ -68,12 +68,12 @@ void agg_renderer<T0,T1>::process(polygon_pattern_symbolizer const& sym,
if ((*marker_ptr)->is_bitmap())
{
// FIXME: copy is necessary atm to transform a
// shared_ptr<image_any> into shared_ptr<image_data_rgba8>
// shared_ptr<image_any> into shared_ptr<image_rgba8>
boost::optional<image_ptr> bitmap = (*marker_ptr)->get_bitmap_data();
if (bitmap) {
mapnik::image_any const& im = *(bitmap)->get();
if (im.is<buffer_type>()) {
// invoke copy ctor of image_data_rgba8
// invoke copy ctor of image_rgba8
pat = std::make_shared<buffer_type>(util::get<buffer_type>(im));
}
}
@ -188,7 +188,7 @@ void agg_renderer<T0,T1>::process(polygon_pattern_symbolizer const& sym,
}
template void agg_renderer<image_data_rgba8>::process(polygon_pattern_symbolizer const&,
template void agg_renderer<image_rgba8>::process(polygon_pattern_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

2
src/agg/process_polygon_symbolizer.cpp
View file

@ -87,7 +87,7 @@ void agg_renderer<T0,T1>::process(polygon_symbolizer const& sym,
});
}
template void agg_renderer<image_data_rgba8>::process(polygon_symbolizer const&,
template void agg_renderer<image_rgba8>::process(polygon_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

4
src/agg/process_raster_symbolizer.cpp
View file

@ -51,7 +51,7 @@ void agg_renderer<T0,T1>::process(raster_symbolizer const& sym,
{
render_raster_symbolizer(
sym, feature, prj_trans, common_,
[&](image_data_rgba8 & target, composite_mode_e comp_op, double opacity,
[&](image_rgba8 & target, composite_mode_e comp_op, double opacity,
int start_x, int start_y) {
composite(*current_buffer_, target,
comp_op, opacity, start_x, start_y);
@ -59,7 +59,7 @@ void agg_renderer<T0,T1>::process(raster_symbolizer const& sym,
);
}
template void agg_renderer<image_data_rgba8>::process(raster_symbolizer const&,
template void agg_renderer<image_rgba8>::process(raster_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

2
src/agg/process_shield_symbolizer.cpp
View file

@ -72,7 +72,7 @@ void agg_renderer<T0,T1>::process(shield_symbolizer const& sym,
}
template void agg_renderer<image_data_rgba8>::process(shield_symbolizer const&,
template void agg_renderer<image_rgba8>::process(shield_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

2
src/agg/process_text_symbolizer.cpp
View file

@ -75,7 +75,7 @@ void agg_renderer<T0,T1>::process(text_symbolizer const& sym,
}
}
template void agg_renderer<image_data_rgba8>::process(text_symbolizer const&,
template void agg_renderer<image_rgba8>::process(text_symbolizer const&,
mapnik::feature_impl &,
proj_transform const&);

8
src/cairo/cairo_context.cpp
View file

@ -53,7 +53,7 @@ struct visitor_context_add_image_1
};
template <>
void visitor_context_add_image_1::operator()<image_data_rgba8> (image_data_rgba8 & data)
void visitor_context_add_image_1::operator()<image_rgba8> (image_rgba8 & data)
{
context_.add_image(x_, y_, data, opacity_);
}
@ -76,7 +76,7 @@ struct visitor_context_add_image_2
};
template <>
void visitor_context_add_image_2::operator()<image_data_rgba8> (image_data_rgba8 & data)
void visitor_context_add_image_2::operator()<image_rgba8> (image_rgba8 & data)
{
context_.add_image(tr_, data, opacity_);
}
@ -398,7 +398,7 @@ void cairo_context::add_image(agg::trans_affine const& tr, image_any & data, dou
util::apply_visitor(detail::visitor_context_add_image_2(*this,tr,opacity), data);
}
void cairo_context::add_image(double x, double y, image_data_rgba8 & data, double opacity)
void cairo_context::add_image(double x, double y, image_rgba8 & data, double opacity)
{
cairo_pattern pattern(data);
pattern.set_origin(x, y);
@ -409,7 +409,7 @@ void cairo_context::add_image(double x, double y, image_data_rgba8 & data, doubl
check_object_status_and_throw_exception(*this);
}
void cairo_context::add_image(agg::trans_affine const& tr, image_data_rgba8 & data, double opacity)
void cairo_context::add_image(agg::trans_affine const& tr, image_rgba8 & data, double opacity)
{
cairo_pattern pattern(data);
if (!tr.is_identity())

2
src/cairo/process_group_symbolizer.cpp
View file

@ -77,7 +77,7 @@ struct thunk_renderer
thunk.opacity_);
}
void operator()(raster_marker_render_thunk<image_data_rgba8> const &thunk) const
void operator()(raster_marker_render_thunk<image_rgba8> const &thunk) const
{
cairo_save_restore guard(context_);
context_.set_operator(thunk.comp_op_);

6
src/cairo/process_line_pattern_symbolizer.cpp
View file

@ -55,7 +55,7 @@ struct visitor_create_pattern
};
template <>
std::shared_ptr<cairo_pattern> visitor_create_pattern::operator()<image_data_rgba8> (image_data_rgba8 & data)
std::shared_ptr<cairo_pattern> visitor_create_pattern::operator()<image_rgba8> (image_rgba8 & data)
{
return std::make_shared<cairo_pattern>(data, opacity_);
}
@ -87,7 +87,7 @@ void cairo_renderer<T>::process(line_pattern_symbolizer const& sym,
cairo_save_restore guard(context_);
context_.set_operator(comp_op);
std::shared_ptr<cairo_pattern> pattern;
std::shared_ptr<image_data_rgba8> image = nullptr;
std::shared_ptr<image_rgba8> image = nullptr;
// TODO - re-implement at renderer level like polygon_pattern symbolizer
double opacity = get<value_double, keys::opacity>(sym, feature, common_.vars_);
if ((*marker)->is_bitmap())
@ -101,7 +101,7 @@ void cairo_renderer<T>::process(line_pattern_symbolizer const& sym,
agg::trans_affine image_tr = agg::trans_affine_scaling(common_.scale_factor_);
auto image_transform = get_optional<transform_type>(sym, keys::image_transform);
if (image_transform) evaluate_transform(image_tr, feature, common_.vars_, *image_transform);
image = render_pattern<image_data_rgba8>(ras, **marker, image_tr, 1.0);
image = render_pattern<image_rgba8>(ras, **marker, image_tr, 1.0);
pattern = std::make_unique<cairo_pattern>(*image, opacity);
width = image->width();
height = image->height();

4
src/cairo/process_polygon_pattern_symbolizer.cpp
View file

@ -58,7 +58,7 @@ struct visitor_set_pattern
};
template <>
void visitor_set_pattern::operator()<image_data_rgba8> (image_data_rgba8 & data)
void visitor_set_pattern::operator()<image_rgba8> (image_rgba8 & data)
{
cairo_pattern pattern(data, opacity_);
pattern.set_extend(CAIRO_EXTEND_REPEAT);
@ -119,7 +119,7 @@ void cairo_renderer<T>::process(polygon_pattern_symbolizer const& sym,
else
{
mapnik::rasterizer ras;
std::shared_ptr<image_data_rgba8> image = render_pattern<image_data_rgba8>(ras, **marker, image_tr, 1.0); //
std::shared_ptr<image_rgba8> image = render_pattern<image_rgba8>(ras, **marker, image_tr, 1.0); //
cairo_pattern pattern(*image, opacity);
pattern.set_extend(CAIRO_EXTEND_REPEAT);
pattern.set_origin(offset_x, offset_y);

2
src/cairo/process_raster_symbolizer.cpp
View file

@ -43,7 +43,7 @@ void cairo_renderer<T>::process(raster_symbolizer const& sym,
cairo_save_restore guard(context_);
render_raster_symbolizer(
sym, feature, prj_trans, common_,
[&](image_data_rgba8 &target, composite_mode_e comp_op, double opacity,
[&](image_rgba8 &target, composite_mode_e comp_op, double opacity,
int start_x, int start_y) {
context_.set_operator(comp_op);
context_.add_image(start_x, start_y, target, opacity);

2
src/feature_style_processor.cpp
View file

@ -55,6 +55,6 @@ template class feature_style_processor<svg_renderer<std::ostream_iterator<char>
template class feature_style_processor<grid_renderer<grid> >;
#endif
template class feature_style_processor<agg_renderer<image_data_rgba8> >;
template class feature_style_processor<agg_renderer<image_rgba8> >;
}

4
src/grid/grid_renderer.cpp
View file

@ -165,7 +165,7 @@ void grid_renderer<T>::render_marker(mapnik::feature_impl const& feature, pixel_
}
else
{
image_data_rgba8 const& data = util::get<image_data_rgba8>(**marker.get_bitmap_data());
image_rgba8 const& data = util::get<image_rgba8>(**marker.get_bitmap_data());
double width = data.width();
double height = data.height();
double cx = 0.5 * width;
@ -179,7 +179,7 @@ void grid_renderer<T>::render_marker(mapnik::feature_impl const& feature, pixel_
}
else
{
image_data_rgba8 target(data.width(), data.height());
image_rgba8 target(data.width(), data.height());
mapnik::scale_image_agg(target,
data,
SCALING_NEAR,

8
src/grid/process_group_symbolizer.cpp
View file

@ -103,7 +103,7 @@ struct thunk_renderer
pixmap_.add_feature(feature_);
}
void operator()(raster_marker_render_thunk<image_data_rgba8> const &thunk) const
void operator()(raster_marker_render_thunk<image_rgba8> const &thunk) const
{
using buf_type = grid_rendering_buffer;
using pixfmt_type = typename grid_renderer_base_type::pixfmt_type;
@ -121,17 +121,17 @@ struct thunk_renderer
void operator()(raster_marker_render_thunk<image_data_gray8> const &thunk) const
{
throw std::runtime_error("Rendering of this image_data_gray8 type is not supported currently by the image_data_rgba8 renderer");
throw std::runtime_error("Rendering of this image_data_gray8 type is not supported currently by the image_rgba8 renderer");
}
void operator()(raster_marker_render_thunk<image_data_gray16> const &thunk) const
{
throw std::runtime_error("Rendering of this image_data_gray16 type is not supported currently by the image_data_rgba8 renderer");
throw std::runtime_error("Rendering of this image_data_gray16 type is not supported currently by the image_rgba8 renderer");
}
void operator()(raster_marker_render_thunk<image_data_gray32f> const &thunk) const
{
throw std::runtime_error("Rendering of this image_data_gray32f type is not supported currently by the image_data_rgba8 renderer");
throw std::runtime_error("Rendering of this image_data_gray32f type is not supported currently by the image_rgba8 renderer");
}
void operator()(text_render_thunk const &thunk) const

2
src/grid/process_markers_symbolizer.cpp
View file

@ -167,7 +167,7 @@ struct raster_markers_rasterizer_dispatch : public raster_markers_dispatch<Detec
{
// In the long term this should be a visitor pattern based on the type of render this->src_ provided that converts
// the destination pixel type required.
render_raster_marker(RendererType(renb_), ras_, util::get<image_data_rgba8>(this->src_), this->feature_, marker_tr, opacity);
render_raster_marker(RendererType(renb_), ras_, util::get<image_rgba8>(this->src_), this->feature_, marker_tr, opacity);
if (!placed_)
{
pixmap_.add_feature(this->feature_);

8
src/image_compositing.cpp
View file

@ -149,14 +149,14 @@ struct rendering_buffer
} // end detail ns
template <>
MAPNIK_DECL void composite(image_data_rgba8 & dst, image_data_rgba8 const& src, composite_mode_e mode,
MAPNIK_DECL void composite(image_rgba8 & dst, image_rgba8 const& src, composite_mode_e mode,
float opacity,
int dx,
int dy)
{
using color = agg::rgba8;
using order = agg::order_rgba;
using const_rendering_buffer = detail::rendering_buffer<image_data_rgba8>;
using const_rendering_buffer = detail::rendering_buffer<image_rgba8>;
using blender_type = agg::comp_op_adaptor_rgba_pre<color, order>;
using pixfmt_type = agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer>;
using renderer_type = agg::renderer_base<pixfmt_type>;
@ -233,9 +233,9 @@ void composite_visitor::operator() (T & dst)
}
template <>
void composite_visitor::operator()<image_data_rgba8> (image_data_rgba8 & dst)
void composite_visitor::operator()<image_rgba8> (image_rgba8 & dst)
{
composite(dst, util::get<image_data_rgba8>(src_), mode_, opacity_, dx_, dy_);
composite(dst, util::get<image_rgba8>(src_), mode_, opacity_, dx_, dy_);
}
template <>

2
src/image_scaling.cpp
View file

@ -165,7 +165,7 @@ void scale_image_agg(T & target, T const& source, scaling_method_e scaling_metho
}
template MAPNIK_DECL void scale_image_agg(image_data_rgba8 &, image_data_rgba8 const&, scaling_method_e,
template MAPNIK_DECL void scale_image_agg(image_rgba8 &, image_rgba8 const&, scaling_method_e,
double, double , double, double , double);
template MAPNIK_DECL void scale_image_agg(image_data_gray8 &, image_data_gray8 const&, scaling_method_e,

80
src/image_util.cpp
View file

@ -126,7 +126,7 @@ MAPNIK_DECL void save_to_stream(T const& image,
// This can be removed once image_any and image_view_any are the only
// items using this template
template <>
MAPNIK_DECL void save_to_stream<image_data_rgba8>(image_data_rgba8 const& image,
MAPNIK_DECL void save_to_stream<image_rgba8>(image_rgba8 const& image,
std::ostream & stream,
std::string const& type,
rgba_palette const& palette)
@ -222,7 +222,7 @@ MAPNIK_DECL void save_to_stream(T const& image,
// This can be removed once image_any and image_view_any are the only
// items using this template
template <>
MAPNIK_DECL void save_to_stream<image_data_rgba8>(image_data_rgba8 const& image,
MAPNIK_DECL void save_to_stream<image_rgba8>(image_rgba8 const& image,
std::ostream & stream,
std::string const& type)
{
@ -321,27 +321,27 @@ MAPNIK_DECL void save_to_file(T const& image, std::string const& filename, rgba_
else throw ImageWriterException("Could not write file to " + filename );
}
// image_data_rgba8
template MAPNIK_DECL void save_to_file<image_data_rgba8>(image_data_rgba8 const&,
// image_rgba8
template MAPNIK_DECL void save_to_file<image_rgba8>(image_rgba8 const&,
std::string const&,
std::string const&);
template MAPNIK_DECL void save_to_file<image_data_rgba8>(image_data_rgba8 const&,
template MAPNIK_DECL void save_to_file<image_rgba8>(image_rgba8 const&,
std::string const&,
std::string const&,
rgba_palette const& palette);
template MAPNIK_DECL void save_to_file<image_data_rgba8>(image_data_rgba8 const&,
template MAPNIK_DECL void save_to_file<image_rgba8>(image_rgba8 const&,
std::string const&);
template MAPNIK_DECL void save_to_file<image_data_rgba8>(image_data_rgba8 const&,
template MAPNIK_DECL void save_to_file<image_rgba8>(image_rgba8 const&,
std::string const&,
rgba_palette const& palette);
template MAPNIK_DECL std::string save_to_string<image_data_rgba8>(image_data_rgba8 const&,
template MAPNIK_DECL std::string save_to_string<image_rgba8>(image_rgba8 const&,
std::string const&);
template MAPNIK_DECL std::string save_to_string<image_data_rgba8>(image_data_rgba8 const&,
template MAPNIK_DECL std::string save_to_string<image_rgba8>(image_rgba8 const&,
std::string const&,
rgba_palette const& palette);
@ -421,7 +421,7 @@ struct is_solid_visitor
}
};
template bool is_solid_visitor::operator()<image_data_rgba8> (image_data_rgba8 const& data);
template bool is_solid_visitor::operator()<image_rgba8> (image_rgba8 const& data);
template bool is_solid_visitor::operator()<image_data_gray8> (image_data_gray8 const& data);
template bool is_solid_visitor::operator()<image_data_gray16> (image_data_gray16 const& data);
template bool is_solid_visitor::operator()<image_data_gray32f> (image_data_gray32f const& data);
@ -447,9 +447,9 @@ MAPNIK_DECL bool is_solid(T const& image)
template MAPNIK_DECL bool is_solid<image_any> (image_any const&);
template MAPNIK_DECL bool is_solid<image_view_any> (image_view_any const&);
// Temporary until image_data_rgba8 is removed from passing
// Temporary until image_rgba8 is removed from passing
template <>
MAPNIK_DECL bool is_solid<image_data_rgba8>(image_data_rgba8 const& image)
MAPNIK_DECL bool is_solid<image_rgba8>(image_rgba8 const& image)
{
detail::is_solid_visitor visitor;
return visitor(image);
@ -476,7 +476,7 @@ struct premultiply_visitor
};
template <>
bool premultiply_visitor::operator()<image_data_rgba8> (image_data_rgba8 & data)
bool premultiply_visitor::operator()<image_rgba8> (image_rgba8 & data)
{
if (!data.get_premultiplied())
{
@ -500,7 +500,7 @@ struct demultiply_visitor
};
template <>
bool demultiply_visitor::operator()<image_data_rgba8> (image_data_rgba8 & data)
bool demultiply_visitor::operator()<image_rgba8> (image_rgba8 & data)
{
if (data.get_premultiplied())
{
@ -539,7 +539,7 @@ template MAPNIK_DECL bool premultiply_alpha<image_any> (image_any &);
// Temporary, can be removed once image_view_any and image_any are the only ones passed
template <>
MAPNIK_DECL bool premultiply_alpha<image_data_rgba8>(image_data_rgba8 & image)
MAPNIK_DECL bool premultiply_alpha<image_rgba8>(image_rgba8 & image)
{
detail::premultiply_visitor visit;
return visit(image);
@ -555,7 +555,7 @@ template MAPNIK_DECL bool demultiply_alpha<image_any> (image_any &);
// Temporary, can be removed once image_view_any and image_any are the only ones passed
template <>
MAPNIK_DECL bool demultiply_alpha<image_data_rgba8>(image_data_rgba8 & image)
MAPNIK_DECL bool demultiply_alpha<image_rgba8>(image_rgba8 & image)
{
detail::demultiply_visitor visit;
return visit(image);
@ -571,7 +571,7 @@ template void set_premultiplied_alpha<image_any> (image_any &, bool);
// Temporary, can be removed once image_view_any and image_any are the only ones passed
template <>
MAPNIK_DECL void set_premultiplied_alpha<image_data_rgba8>(image_data_rgba8 & image, bool status)
MAPNIK_DECL void set_premultiplied_alpha<image_rgba8>(image_rgba8 & image, bool status)
{
detail::set_premultiplied_visitor visit(status);
visit(image);
@ -596,9 +596,9 @@ struct visitor_set_alpha
};
template <>
void visitor_set_alpha::operator()<image_data_rgba8> (image_data_rgba8 & data)
void visitor_set_alpha::operator()<image_rgba8> (image_rgba8 & data)
{
using pixel_type = typename image_data_rgba8::pixel_type;
using pixel_type = typename image_rgba8::pixel_type;
for (unsigned int y = 0; y < data.height(); ++y)
{
pixel_type* row_to = data.getRow(y);
@ -635,7 +635,7 @@ MAPNIK_DECL void set_alpha<image_any> (image_any & data, float opacity)
// TEMPORARY can be removed once image_any is only way it is being passed.
template<>
MAPNIK_DECL void set_alpha<image_data_rgba8> (image_data_rgba8 & data, float opacity)
MAPNIK_DECL void set_alpha<image_rgba8> (image_rgba8 & data, float opacity)
{
// Prior to calling the data must not be premultiplied
bool remultiply = mapnik::demultiply_alpha(data);
@ -659,9 +659,9 @@ struct visitor_set_grayscale_to_alpha
};
template <>
void visitor_set_grayscale_to_alpha::operator()<image_data_rgba8> (image_data_rgba8 & data)
void visitor_set_grayscale_to_alpha::operator()<image_rgba8> (image_rgba8 & data)
{
using pixel_type = typename image_data_rgba8::pixel_type;
using pixel_type = typename image_rgba8::pixel_type;
for (unsigned int y = 0; y < data.height(); ++y)
{
pixel_type* row_from = data.getRow(y);
@ -696,7 +696,7 @@ MAPNIK_DECL void set_grayscale_to_alpha<image_any> (image_any & data)
// TEMPORARY can be removed once image_any is only way it is being passed.
template<>
MAPNIK_DECL void set_grayscale_to_alpha<image_data_rgba8> (image_data_rgba8 & data)
MAPNIK_DECL void set_grayscale_to_alpha<image_rgba8> (image_rgba8 & data)
{
// Prior to calling the data must not be premultiplied
bool remultiply = mapnik::demultiply_alpha(data);
@ -727,9 +727,9 @@ struct visitor_set_color_to_alpha
};
template <>
void visitor_set_color_to_alpha::operator()<image_data_rgba8> (image_data_rgba8 & data)
void visitor_set_color_to_alpha::operator()<image_rgba8> (image_rgba8 & data)
{
using pixel_type = typename image_data_rgba8::pixel_type;
using pixel_type = typename image_rgba8::pixel_type;
for (unsigned y = 0; y < data.height(); ++y)
{
pixel_type* row_from = data.getRow(y);
@ -763,7 +763,7 @@ MAPNIK_DECL void set_color_to_alpha<image_any> (image_any & data, color const& c
// TEMPORARY can be removed once image_any is only way it is being passed.
template<>
MAPNIK_DECL void set_color_to_alpha<image_data_rgba8> (image_data_rgba8 & data, color const& c)
MAPNIK_DECL void set_color_to_alpha<image_rgba8> (image_rgba8 & data, color const& c)
{
// Prior to calling the data must not be premultiplied
bool remultiply = mapnik::demultiply_alpha(data);
@ -835,7 +835,7 @@ template MAPNIK_DECL void fill(image_any &, double const&);
// Temporary remove these later!
template <>
MAPNIK_DECL void fill<image_data_rgba8, color> (image_data_rgba8 & data , color const& val)
MAPNIK_DECL void fill<image_rgba8, color> (image_rgba8 & data , color const& val)
{
detail::visitor_fill<color> visitor(val);
visitor(data);
@ -843,7 +843,7 @@ MAPNIK_DECL void fill<image_data_rgba8, color> (image_data_rgba8 & data , color
// Temporary remove these later!
template <>
MAPNIK_DECL void fill<image_data_rgba8, uint32_t> (image_data_rgba8 & data , uint32_t const& val)
MAPNIK_DECL void fill<image_rgba8, uint32_t> (image_rgba8 & data , uint32_t const& val)
{
detail::visitor_fill<uint32_t> visitor(val);
visitor(data);
@ -851,7 +851,7 @@ MAPNIK_DECL void fill<image_data_rgba8, uint32_t> (image_data_rgba8 & data , uin
// Temporary remove these later!
template <>
MAPNIK_DECL void fill<image_data_rgba8, int32_t> (image_data_rgba8 & data , int32_t const& val)
MAPNIK_DECL void fill<image_rgba8, int32_t> (image_rgba8 & data , int32_t const& val)
{
detail::visitor_fill<int32_t> visitor(val);
visitor(data);
@ -894,10 +894,10 @@ struct visitor_set_rectangle
};
template <>
void visitor_set_rectangle::operator()<image_data_rgba8> (image_data_rgba8 & dst)
void visitor_set_rectangle::operator()<image_rgba8> (image_rgba8 & dst)
{
using pixel_type = typename image_data_rgba8::pixel_type;
image_data_rgba8 src = util::get<image_data_rgba8>(src_);
using pixel_type = typename image_rgba8::pixel_type;
image_rgba8 src = util::get<image_rgba8>(src_);
box2d<int> ext0(0,0,dst.width(),dst.height());
box2d<int> ext1(x0_,y0_,x0_+src.width(),y0_+src.height());
@ -973,7 +973,7 @@ struct visitor_composite_pixel
};
template<>
void visitor_composite_pixel::operator()<image_data_rgba8> (image_data_rgba8 & data)
void visitor_composite_pixel::operator()<image_rgba8> (image_rgba8 & data)
{
using color_type = agg::rgba8;
using value_type = color_type::value_type;
@ -1002,7 +1002,7 @@ MAPNIK_DECL void composite_pixel(T & data, unsigned op, int x, int y, unsigned c
// Temporary delete later
template <>
MAPNIK_DECL void composite_pixel<image_data_rgba8>(image_data_rgba8 & data, unsigned op, int x, int y, unsigned c, unsigned cover, double opacity )
MAPNIK_DECL void composite_pixel<image_rgba8>(image_rgba8 & data, unsigned op, int x, int y, unsigned c, unsigned cover, double opacity )
{
detail::visitor_composite_pixel visitor(op, x, y, c, cover, opacity);
visitor(data);
@ -1078,7 +1078,7 @@ template MAPNIK_DECL void set_pixel(image_any &, std::size_t, std::size_t, doubl
// Temporary remove these later!
template <>
MAPNIK_DECL void set_pixel<image_data_rgba8, color> (image_data_rgba8 & data, std::size_t x, std::size_t y, color const& val)
MAPNIK_DECL void set_pixel<image_rgba8, color> (image_rgba8 & data, std::size_t x, std::size_t y, color const& val)
{
detail::visitor_set_pixel<color> visitor(x, y, val);
visitor(data);
@ -1086,7 +1086,7 @@ MAPNIK_DECL void set_pixel<image_data_rgba8, color> (image_data_rgba8 & data, st
// Temporary remove these later!
template <>
MAPNIK_DECL void set_pixel<image_data_rgba8, uint32_t> (image_data_rgba8 & data, std::size_t x, std::size_t y, uint32_t const& val)
MAPNIK_DECL void set_pixel<image_rgba8, uint32_t> (image_rgba8 & data, std::size_t x, std::size_t y, uint32_t const& val)
{
detail::visitor_set_pixel<uint32_t> visitor(x, y, val);
visitor(data);
@ -1094,7 +1094,7 @@ MAPNIK_DECL void set_pixel<image_data_rgba8, uint32_t> (image_data_rgba8 & data,
// Temporary remove these later!
template <>
MAPNIK_DECL void set_pixel<image_data_rgba8, int32_t> (image_data_rgba8 & data, std::size_t x, std::size_t y, int32_t const& val)
MAPNIK_DECL void set_pixel<image_rgba8, int32_t> (image_rgba8 & data, std::size_t x, std::size_t y, int32_t const& val)
{
detail::visitor_set_pixel<int32_t> visitor(x, y, val);
visitor(data);
@ -1176,7 +1176,7 @@ template MAPNIK_DECL double get_pixel(image_any const&, std::size_t, std::size_t
// Temporary remove these later!
template <>
MAPNIK_DECL color get_pixel<image_data_rgba8, color> (image_data_rgba8 const& data, std::size_t x, std::size_t y)
MAPNIK_DECL color get_pixel<image_rgba8, color> (image_rgba8 const& data, std::size_t x, std::size_t y)
{
detail::visitor_get_pixel<color> visitor(x, y);
return visitor(data);
@ -1184,7 +1184,7 @@ MAPNIK_DECL color get_pixel<image_data_rgba8, color> (image_data_rgba8 const& da
// Temporary remove these later!
template <>
MAPNIK_DECL uint32_t get_pixel<image_data_rgba8, uint32_t> (image_data_rgba8 const& data, std::size_t x, std::size_t y)
MAPNIK_DECL uint32_t get_pixel<image_rgba8, uint32_t> (image_rgba8 const& data, std::size_t x, std::size_t y)
{
detail::visitor_get_pixel<uint32_t> visitor(x, y);
return visitor(data);
@ -1192,7 +1192,7 @@ MAPNIK_DECL uint32_t get_pixel<image_data_rgba8, uint32_t> (image_data_rgba8 con
// Temporary remove these later!
template <>
MAPNIK_DECL int32_t get_pixel<image_data_rgba8, int32_t> (image_data_rgba8 const& data, std::size_t x, std::size_t y)
MAPNIK_DECL int32_t get_pixel<image_rgba8, int32_t> (image_rgba8 const& data, std::size_t x, std::size_t y)
{
detail::visitor_get_pixel<int32_t> visitor(x, y);
return visitor(data);

2
src/image_util_jpeg.cpp
View file

@ -65,7 +65,7 @@ void process_rgba8_jpeg(T const& image, std::string const& t, std::ostream & str
}
template<>
void jpeg_saver::operator()<image_data_rgba8> (image_data_rgba8 const& image) const
void jpeg_saver::operator()<image_rgba8> (image_rgba8 const& image) const
{
process_rgba8_jpeg(image, t_, stream_);
}

4
src/image_util_png.cpp
View file

@ -259,7 +259,7 @@ void process_rgba8_png(T const& image,
}
template<>
void png_saver_pal::operator()<image_data_rgba8> (image_data_rgba8 const& image) const
void png_saver_pal::operator()<image_rgba8> (image_rgba8 const& image) const
{
process_rgba8_png_pal(image, t_, stream_, pal_);
}
@ -271,7 +271,7 @@ void png_saver_pal::operator()<image_view_rgba8> (image_view_rgba8 const& image)
}
template<>
void png_saver::operator()<image_data_rgba8> (image_data_rgba8 const& image) const
void png_saver::operator()<image_rgba8> (image_rgba8 const& image) const
{
process_rgba8_png(image, t_, stream_);
}

2
src/image_util_tiff.cpp
View file

@ -181,7 +181,7 @@ void tiff_saver::operator() (T const& image) const
#endif
}
template void tiff_saver::operator() (image_data_rgba8 const& image) const;
template void tiff_saver::operator() (image_rgba8 const& image) const;
template void tiff_saver::operator() (image_data_gray8 const& image) const;
template void tiff_saver::operator() (image_data_gray16 const& image) const;
template void tiff_saver::operator() (image_data_gray32f const& image) const;

4
src/image_util_webp.cpp
View file

@ -360,7 +360,7 @@ void process_rgba8_webp(T const& image, std::string const& t, std::ostream & str
}
template <>
void webp_saver::operator()<image_data_rgba8> (image_data_rgba8 const& image) const
void webp_saver::operator()<image_rgba8> (image_rgba8 const& image) const
{
process_rgba8_webp(image, t_, stream_);
}
@ -377,7 +377,7 @@ void webp_saver::operator() (T const& image) const
throw ImageWriterException("Mapnik does not support webp grayscale images");
}
template void webp_saver::operator()<image_data_rgba8> (image_data_rgba8 const& image) const;
template void webp_saver::operator()<image_rgba8> (image_rgba8 const& image) const;
template void webp_saver::operator()<image_data_gray8> (image_data_gray8 const& image) const;
template void webp_saver::operator()<image_data_gray16> (image_data_gray16 const& image) const;
template void webp_saver::operator()<image_data_gray32f> (image_data_gray32f const& image) const;

6
src/jpeg_reader.cpp
View file

@ -85,7 +85,7 @@ public:
unsigned height() const final;
boost::optional<box2d<double> > bounding_box() const final;
inline bool has_alpha() const final { return false; }
void read(unsigned x,unsigned y,image_data_rgba8& image) final;
void read(unsigned x,unsigned y,image_rgba8& image) final;
image_any read(unsigned x, unsigned y, unsigned width, unsigned height) final;
private:
void init();
@ -265,7 +265,7 @@ boost::optional<box2d<double> > jpeg_reader<T>::bounding_box() const
}
template <typename T>
void jpeg_reader<T>::read(unsigned x0, unsigned y0, image_data_rgba8& image)
void jpeg_reader<T>::read(unsigned x0, unsigned y0, image_rgba8& image)
{
stream_.clear();
stream_.seekg(0, std::ios_base::beg);
@ -322,7 +322,7 @@ void jpeg_reader<T>::read(unsigned x0, unsigned y0, image_data_rgba8& image)
template <typename T>
image_any jpeg_reader<T>::read(unsigned x, unsigned y, unsigned width, unsigned height)
{
image_data_rgba8 data(width,height, true, true);
image_rgba8 data(width,height, true, true);
read(x, y, data);
return image_any(std::move(data));
}

4
src/marker_cache.cpp
View file

@ -62,7 +62,7 @@ marker_cache::marker_cache()
"<svg width='100%' height='100%' version='1.1' xmlns='http://www.w3.org/2000/svg'>"
"<path fill='#0000FF' stroke='black' stroke-width='.5' d='m 31.698405,7.5302648 -8.910967,-6.0263712 0.594993,4.8210971 -18.9822542,0 0,2.4105482 18.9822542,0 -0.594993,4.8210971 z'/>"
"</svg>");
image_data_rgba8 im(4,4,true,true);
image_rgba8 im(4,4,true,true);
im.set(0xff000000);
boost::optional<mapnik::image_ptr> bitmap_data = boost::optional<mapnik::image_ptr>(std::make_shared<image_any>(std::move(im)));
marker_ptr mark = std::make_shared<mapnik::marker>(bitmap_data);
@ -135,7 +135,7 @@ struct visitor_create_marker
};
template<>
marker_ptr visitor_create_marker::operator()<image_data_rgba8> (image_data_rgba8 & data)
marker_ptr visitor_create_marker::operator()<image_rgba8> (image_rgba8 & data)
{
std::shared_ptr<image_any> image = std::make_shared<image_any>(data);
mapnik::premultiply_alpha(*image);

4
src/miniz_png.cpp
View file

@ -363,9 +363,9 @@ const mz_uint8 PNGWriter::IEND_tpl[] = {
template void PNGWriter::writeIDAT<image_data_gray8>(image_data_gray8 const& image);
template void PNGWriter::writeIDAT<image_view_gray8>(image_view_gray8 const& image);
template void PNGWriter::writeIDAT<image_data_rgba8>(image_data_rgba8 const& image);
template void PNGWriter::writeIDAT<image_rgba8>(image_rgba8 const& image);
template void PNGWriter::writeIDAT<image_view_rgba8>(image_view_rgba8 const& image);
template void PNGWriter::writeIDATStripAlpha<image_data_rgba8>(image_data_rgba8 const& image);
template void PNGWriter::writeIDATStripAlpha<image_rgba8>(image_rgba8 const& image);
template void PNGWriter::writeIDATStripAlpha<image_view_rgba8>(image_view_rgba8 const& image);
}}

6
src/png_reader.cpp
View file

@ -80,7 +80,7 @@ public:
unsigned height() const final;
boost::optional<box2d<double> > bounding_box() const final;
inline bool has_alpha() const final { return has_alpha_; }
void read(unsigned x,unsigned y,image_data_rgba8& image) final;
void read(unsigned x,unsigned y,image_rgba8& image) final;
image_any read(unsigned x, unsigned y, unsigned width, unsigned height) final;
private:
void init();
@ -226,7 +226,7 @@ boost::optional<box2d<double> > png_reader<T>::bounding_box() const
}
template <typename T>
void png_reader<T>::read(unsigned x0, unsigned y0,image_data_rgba8& image)
void png_reader<T>::read(unsigned x0, unsigned y0,image_rgba8& image)
{
stream_.clear();
stream_.seekg(0, std::ios_base::beg);
@ -312,7 +312,7 @@ void png_reader<T>::read(unsigned x0, unsigned y0,image_data_rgba8& image)
template <typename T>
image_any png_reader<T>::read(unsigned x, unsigned y, unsigned width, unsigned height)
{
image_data_rgba8 data(width,height);
image_rgba8 data(width,height);
read(x, y, data);
return image_any(std::move(data));
}

8
src/raster_colorizer.cpp
View file

@ -123,7 +123,7 @@ bool raster_colorizer::add_stop(colorizer_stop const& stop)
}
template <typename T>
void raster_colorizer::colorize(image_data_rgba8 & out, T const& in,
void raster_colorizer::colorize(image_rgba8 & out, T const& in,
boost::optional<double> const& nodata,
feature_impl const& f) const
{
@ -286,13 +286,13 @@ unsigned raster_colorizer::get_color(float value) const
}
template void raster_colorizer::colorize(image_data_rgba8 & out, image_data_gray8 const& in,
template void raster_colorizer::colorize(image_rgba8 & out, image_data_gray8 const& in,
boost::optional<double>const& nodata,
feature_impl const& f) const;
template void raster_colorizer::colorize(image_data_rgba8 & out, image_data_gray16 const& in,
template void raster_colorizer::colorize(image_rgba8 & out, image_data_gray16 const& in,
boost::optional<double>const& nodata,
feature_impl const& f) const;
template void raster_colorizer::colorize(image_data_rgba8 & out, image_data_gray32f const& in,
template void raster_colorizer::colorize(image_rgba8 & out, image_data_gray32f const& in,
boost::optional<double>const& nodata,
feature_impl const& f) const;

2
src/renderer_common/process_group_symbolizer.cpp
View file

@ -40,7 +40,7 @@ vector_marker_render_thunk::vector_marker_render_thunk(svg_path_ptr const& src,
{}
template <>
raster_marker_render_thunk<image_data_rgba8>::raster_marker_render_thunk(image_data_rgba8 & src,
raster_marker_render_thunk<image_rgba8>::raster_marker_render_thunk(image_rgba8 & src,
agg::trans_affine const& marker_trans,
double opacity,
composite_mode_e comp_op,

4
src/renderer_common/render_pattern.cpp
View file

@ -38,7 +38,7 @@
namespace mapnik {
template <>
std::shared_ptr<image_data_rgba8> render_pattern<image_data_rgba8>(rasterizer & ras,
std::shared_ptr<image_rgba8> render_pattern<image_rgba8>(rasterizer & ras,
marker const& marker,
agg::trans_affine const& tr,
double opacity)
@ -54,7 +54,7 @@ std::shared_ptr<image_data_rgba8> render_pattern<image_data_rgba8>(rasterizer &
mtx.translate(0.5 * bbox.width(), 0.5 * bbox.height());
mtx = tr * mtx;
std::shared_ptr<mapnik::image_data_rgba8> image = std::make_shared<mapnik::image_data_rgba8>(bbox.width(), bbox.height());
std::shared_ptr<mapnik::image_rgba8> image = std::make_shared<mapnik::image_rgba8>(bbox.width(), bbox.height());
agg::rendering_buffer buf(image->getBytes(), image->width(), image->height(), image->width() * 4);
pixfmt pixf(buf);
renderer_base renb(pixf);

2
src/text/renderer.cpp
View file

@ -358,7 +358,7 @@ grid_text_renderer<T>::grid_text_renderer(pixmap_type &pixmap,
: text_renderer(HALO_RASTERIZER_FAST, comp_op, src_over, scale_factor),
pixmap_(pixmap) {}
template class agg_text_renderer<image_data_rgba8>;
template class agg_text_renderer<image_rgba8>;
template class grid_text_renderer<grid>;
} // namespace mapnik

26
src/tiff_reader.cpp
View file

@ -153,7 +153,7 @@ public:
unsigned height() const final;
boost::optional<box2d<double> > bounding_box() const final;
inline bool has_alpha() const final { return has_alpha_; }
void read(unsigned x,unsigned y,image_data_rgba8& image) final;
void read(unsigned x,unsigned y,image_rgba8& image) final;
image_any read(unsigned x, unsigned y, unsigned width, unsigned height) final;
// methods specific to tiff reader
unsigned bits_per_sample() const { return bps_; }
@ -168,8 +168,8 @@ private:
tiff_reader(const tiff_reader&);
tiff_reader& operator=(const tiff_reader&);
void init();
void read_generic(unsigned x,unsigned y,image_data_rgba8& image);
void read_stripped(unsigned x,unsigned y,image_data_rgba8& image);
void read_generic(unsigned x,unsigned y,image_rgba8& image);
void read_stripped(unsigned x,unsigned y,image_rgba8& image);
template <typename ImageData>
void read_tiled(unsigned x,unsigned y, ImageData & image);
@ -377,7 +377,7 @@ boost::optional<box2d<double> > tiff_reader<T>::bounding_box() const
}
template <typename T>
void tiff_reader<T>::read(unsigned x,unsigned y,image_data_rgba8& image)
void tiff_reader<T>::read(unsigned x,unsigned y,image_rgba8& image)
{
if (read_method_==stripped)
{
@ -464,7 +464,7 @@ struct tiff_reader_traits
// default specialization that expands into RGBA
template <>
struct tiff_reader_traits<image_data_rgba8>
struct tiff_reader_traits<image_rgba8>
{
using pixel_type = std::uint32_t;
static bool read_tile(TIFF * tif, unsigned x0, unsigned y0, pixel_type* buf, std::size_t tile_width, std::size_t tile_height)
@ -518,7 +518,7 @@ image_any tiff_reader<T>::read(unsigned x0, unsigned y0, unsigned width, unsigne
TIFF* tif = open(stream_);
if (tif)
{
image_data_rgba8 data(width, height, true, premultiplied_alpha_);
image_rgba8 data(width, height, true, premultiplied_alpha_);
std::size_t element_size = sizeof(detail::rgb8);
std::size_t size_to_allocate = (TIFFScanlineSize(tif) + element_size - 1)/element_size;
const std::unique_ptr<detail::rgb8[]> scanline(new detail::rgb8[size_to_allocate]);
@ -532,7 +532,7 @@ image_any tiff_reader<T>::read(unsigned x0, unsigned y0, unsigned width, unsigne
{
if (y >= y0)
{
image_data_rgba8::pixel_type * row = data.getRow(y - y0);
image_rgba8::pixel_type * row = data.getRow(y - y0);
std::transform(scanline.get() + start_x, scanline.get() + end_x, row, detail::rgb8_to_rgba8());
}
}
@ -543,13 +543,13 @@ image_any tiff_reader<T>::read(unsigned x0, unsigned y0, unsigned width, unsigne
}
case 16:
{
image_data_rgba8 data(width,height,true,premultiplied_alpha_);
image_rgba8 data(width,height,true,premultiplied_alpha_);
read(x0, y0, data);
return image_any(std::move(data));
}
case 32:
{
image_data_rgba8 data(width,height,true,premultiplied_alpha_);
image_rgba8 data(width,height,true,premultiplied_alpha_);
read(x0, y0, data);
return image_any(std::move(data));
}
@ -567,7 +567,7 @@ image_any tiff_reader<T>::read(unsigned x0, unsigned y0, unsigned width, unsigne
//PHOTOMETRIC_ITULAB = 10;
//PHOTOMETRIC_LOGL = 32844;
//PHOTOMETRIC_LOGLUV = 32845;
image_data_rgba8 data(width,height, true, premultiplied_alpha_);
image_rgba8 data(width,height, true, premultiplied_alpha_);
read(x0, y0, data);
return image_any(std::move(data));
}
@ -576,7 +576,7 @@ image_any tiff_reader<T>::read(unsigned x0, unsigned y0, unsigned width, unsigne
}
template <typename T>
void tiff_reader<T>::read_generic(unsigned, unsigned, image_data_rgba8& image)
void tiff_reader<T>::read_generic(unsigned, unsigned, image_rgba8& image)
{
TIFF* tif = open(stream_);
if (tif)
@ -630,12 +630,12 @@ void tiff_reader<T>::read_tiled(unsigned x0,unsigned y0, ImageData & image)
template <typename T>
void tiff_reader<T>::read_stripped(unsigned x0,unsigned y0,image_data_rgba8& image)
void tiff_reader<T>::read_stripped(unsigned x0,unsigned y0,image_rgba8& image)
{
TIFF* tif = open(stream_);
if (tif)
{
image_data_rgba8 strip(width_,rows_per_strip_,false);
image_rgba8 strip(width_,rows_per_strip_,false);
int width=image.width();
int height=image.height();

2
src/warp.cpp
View file

@ -210,7 +210,7 @@ void reproject_and_scale_raster(raster & target, raster const& source,
util::apply_visitor(warper, source.data_);
}
template MAPNIK_DECL void warp_image (image_data_rgba8&, image_data_rgba8 const&, proj_transform const&,
template MAPNIK_DECL void warp_image (image_rgba8&, image_rgba8 const&, proj_transform const&,
box2d<double> const&, box2d<double> const&, double, double, unsigned, scaling_method_e, double);
template MAPNIK_DECL void warp_image (image_data_gray8&, image_data_gray8 const&, proj_transform const&,

6
src/webp_reader.cpp
View file

@ -124,7 +124,7 @@ public:
unsigned height() const final;
boost::optional<box2d<double> > bounding_box() const final;
inline bool has_alpha() const final { return has_alpha_; }
void read(unsigned x,unsigned y,image_data_rgba8& image) final;
void read(unsigned x,unsigned y,image_rgba8& image) final;
image_any read(unsigned x, unsigned y, unsigned width, unsigned height) final;
private:
void init();
@ -236,7 +236,7 @@ boost::optional<box2d<double> > webp_reader<T>::bounding_box() const
}
template <typename T>
void webp_reader<T>::read(unsigned x0, unsigned y0,image_data_rgba8& image)
void webp_reader<T>::read(unsigned x0, unsigned y0,image_rgba8& image)
{
WebPDecoderConfig config;
config_guard guard(config);
@ -270,7 +270,7 @@ void webp_reader<T>::read(unsigned x0, unsigned y0,image_data_rgba8& image)
template <typename T>
image_any webp_reader<T>::read(unsigned x, unsigned y, unsigned width, unsigned height)
{
image_data_rgba8 data(width,height);
image_rgba8 data(width,height);
read(x, y, data);
return image_any(std::move(data));
}

4
tests/cpp_tests/exceptions_test.cpp
View file

@ -82,8 +82,8 @@ int main(int argc, char** argv)
mapnik::Map m = map;
m.add_layer(l);
m.zoom_all();
mapnik::image_data_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m,im);
mapnik::image_rgba8 im(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_rgba8> ren(m,im);
//std::clog << mapnik::save_map_to_string(m) << "\n";
BOOST_TEST(true);
// should throw here with "CSV Plugin: no attribute 'foo'. Valid attributes are: x,y."

4
tests/cpp_tests/fontset_runtime_test.cpp
View file

@ -81,8 +81,8 @@ int main(int argc, char** argv)
m.insert_style("style", std::move(the_style) );
m.zoom_to_box(mapnik::box2d<double>(-256,-256,
256,256));
mapnik::image_data_rgba8 buf(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(m,buf);
mapnik::image_rgba8 buf(m.width(),m.height());
mapnik::agg_renderer<mapnik::image_rgba8> ren(m,buf);
ren.apply();
} catch (std::exception const& ex) {
BOOST_TEST_EQ(std::string(ex.what()),std::string("Unable to find specified font face 'DejaVu Sans Book' in font set: 'fontset'"));

4
tests/cpp_tests/image_io_test.cpp
View file

@ -45,7 +45,7 @@ int main(int argc, char** argv)
try
{
mapnik::image_data_rgba8 im(-10,-10); // should throw rather than overflow
mapnik::image_rgba8 im(-10,-10); // should throw rather than overflow
BOOST_TEST( im.width() < 10 ); // should not get here, but if we did this test should fail
}
catch (std::exception const& ex)
@ -57,7 +57,7 @@ int main(int argc, char** argv)
mapnik::cairo_surface_ptr image_surface(
cairo_image_surface_create(CAIRO_FORMAT_ARGB32,256,257),
mapnik::cairo_surface_closer());
mapnik::image_data_rgba8 im_data(cairo_image_surface_get_width(&*image_surface), cairo_image_surface_get_height(&*image_surface));
mapnik::image_rgba8 im_data(cairo_image_surface_get_width(&*image_surface), cairo_image_surface_get_height(&*image_surface));
im_data.set(1);
BOOST_TEST( (unsigned)im_data(0,0) == unsigned(1) );
// Should set back to fully transparent

4
tests/cpp_tests/image_painted_test.cpp
View file

@ -59,8 +59,8 @@ int main(int argc, char** argv)
m.zoom_all();
image_data_rgba8 image(m.width(), m.height());
agg_renderer<image_data_rgba8> ren(m, image);
image_rgba8 image(m.width(), m.height());
agg_renderer<image_rgba8> ren(m, image);
ren.apply();
BOOST_TEST_EQ(image.painted(), true);

16
tests/cpp_tests/map_request_test.cpp
View file

@ -29,7 +29,7 @@ bool compare_images(std::string const& src_fn,std::string const& dest_fn)
{
throw mapnik::image_reader_exception("Failed to load: " + dest_fn);
}
std::shared_ptr<image_data_rgba8> image_ptr1 = std::make_shared<image_data_rgba8>(reader1->width(),reader1->height());
std::shared_ptr<image_rgba8> image_ptr1 = std::make_shared<image_rgba8>(reader1->width(),reader1->height());
reader1->read(0,0,*image_ptr1);
std::unique_ptr<mapnik::image_reader> reader2(mapnik::get_image_reader(src_fn,"png"));
@ -37,11 +37,11 @@ bool compare_images(std::string const& src_fn,std::string const& dest_fn)
{
throw mapnik::image_reader_exception("Failed to load: " + src_fn);
}
std::shared_ptr<image_data_rgba8> image_ptr2 = std::make_shared<image_data_rgba8>(reader2->width(),reader2->height());
std::shared_ptr<image_rgba8> image_ptr2 = std::make_shared<image_rgba8>(reader2->width(),reader2->height());
reader2->read(0,0,*image_ptr2);
image_data_rgba8 const& dest = *image_ptr1;
image_data_rgba8 const& src = *image_ptr2;
image_rgba8 const& dest = *image_ptr1;
image_rgba8 const& src = *image_ptr2;
unsigned int width = src.width();
unsigned int height = src.height();
@ -77,11 +77,11 @@ int main(int argc, char** argv)
mapnik::Map m(256,256);
mapnik::load_map(m,"./tests/data/good_maps/marker-text-line.xml",false);
m.zoom_all();
mapnik::image_data_rgba8 im(m.width(),m.height());
mapnik::image_rgba8 im(m.width(),m.height());
double scale_factor = 1.2;
// render normally with apply() and just map and image
mapnik::agg_renderer<mapnik::image_data_rgba8> renderer1(m,im,scale_factor);
mapnik::agg_renderer<mapnik::image_rgba8> renderer1(m,im,scale_factor);
renderer1.apply();
std::string actual1("/tmp/map-request-marker-text-line-actual1.png");
//mapnik::save_to_file(im,expected);
@ -99,7 +99,7 @@ int main(int argc, char** argv)
// render using apply() and mapnik::request
mapnik::attributes vars;
mapnik::agg_renderer<mapnik::image_data_rgba8> renderer2(m,req,vars,im,scale_factor);
mapnik::agg_renderer<mapnik::image_rgba8> renderer2(m,req,vars,im,scale_factor);
renderer2.apply();
std::string actual2("/tmp/map-request-marker-text-line-actual2.png");
mapnik::save_to_file(im,actual2);
@ -111,7 +111,7 @@ int main(int argc, char** argv)
mapnik::fill(im, 0);
// render with apply_to_layer api and mapnik::request params passed to apply_to_layer
mapnik::agg_renderer<mapnik::image_data_rgba8> renderer3(m,req,vars,im,scale_factor);
mapnik::agg_renderer<mapnik::image_rgba8> renderer3(m,req,vars,im,scale_factor);
renderer3.start_map_processing(m);
mapnik::projection map_proj(m.srs(),true);
double scale_denom = mapnik::scale_denominator(req.scale(),map_proj.is_geographic());

12
tests/cxx/tiff_io.cpp
View file

@ -75,7 +75,7 @@ SECTION("scan rgb8 striped") {
REQUIRE( reader2->width() == 512 );
REQUIRE( reader2->height() == 512 );
mapnik::image_any data = reader->read(0, 0, reader->width(), reader->height());
REQUIRE( data.is<mapnik::image_data_rgba8>() == true );
REQUIRE( data.is<mapnik::image_rgba8>() == true );
TIFF_ASSERT_SIZE( data,reader );
TIFF_ASSERT_NO_ALPHA( data );
TIFF_READ_ONE_PIXEL
@ -105,7 +105,7 @@ SECTION("scan rgb8 tiled") {
REQUIRE( reader2->width() == 512 );
REQUIRE( reader2->height() == 512 );
mapnik::image_any data = reader->read(0, 0, reader->width(), reader->height());
REQUIRE( data.is<mapnik::image_data_rgba8>() == true );
REQUIRE( data.is<mapnik::image_rgba8>() == true );
TIFF_ASSERT_SIZE( data,reader );
TIFF_ASSERT_NO_ALPHA( data );
TIFF_READ_ONE_PIXEL
@ -121,7 +121,7 @@ SECTION("rgba8 striped") {
REQUIRE( tiff_reader.photometric() == PHOTOMETRIC_RGB );
REQUIRE( tiff_reader.compression() == COMPRESSION_ADOBE_DEFLATE );
mapnik::image_any data = reader->read(0, 0, reader->width(), reader->height());
REQUIRE( data.is<mapnik::image_data_rgba8>() == true );
REQUIRE( data.is<mapnik::image_rgba8>() == true );
TIFF_ASSERT_SIZE( data,reader );
TIFF_ASSERT_ALPHA( data );
TIFF_READ_ONE_PIXEL
@ -137,7 +137,7 @@ SECTION("rgba8 tiled") {
REQUIRE( tiff_reader.photometric() == PHOTOMETRIC_RGB );
REQUIRE( tiff_reader.compression() == COMPRESSION_LZW );
mapnik::image_any data = reader->read(0, 0, reader->width(), reader->height());
REQUIRE( data.is<mapnik::image_data_rgba8>() == true );
REQUIRE( data.is<mapnik::image_rgba8>() == true );
TIFF_ASSERT_SIZE( data,reader );
TIFF_ASSERT_ALPHA( data );
TIFF_READ_ONE_PIXEL
@ -153,7 +153,7 @@ SECTION("rgb8 striped") {
REQUIRE( tiff_reader.photometric() == PHOTOMETRIC_RGB );
REQUIRE( tiff_reader.compression() == COMPRESSION_NONE );
mapnik::image_any data = reader->read(0, 0, reader->width(), reader->height());
REQUIRE( data.is<mapnik::image_data_rgba8>() == true );
REQUIRE( data.is<mapnik::image_rgba8>() == true );
TIFF_ASSERT_SIZE( data,reader );
TIFF_ASSERT_NO_ALPHA( data );
TIFF_READ_ONE_PIXEL
@ -169,7 +169,7 @@ SECTION("rgb8 tiled") {
REQUIRE( tiff_reader.photometric() == PHOTOMETRIC_RGB );
REQUIRE( tiff_reader.compression() == COMPRESSION_LZW );
mapnik::image_any data = reader->read(0, 0, reader->width(), reader->height());
REQUIRE( data.is<mapnik::image_data_rgba8>() == true );
REQUIRE( data.is<mapnik::image_rgba8>() == true );
TIFF_ASSERT_SIZE( data,reader );
TIFF_ASSERT_NO_ALPHA( data );
TIFF_READ_ONE_PIXEL

4
utils/nik2img/nik2img.cpp
View file

@ -110,7 +110,7 @@ int main (int argc,char** argv)
mapnik::Map map(600,400);
mapnik::load_map(map,xml_file,true);
map.zoom_all();
mapnik::image_data_rgba8 im(map.width(),map.height());
mapnik::image_rgba8 im(map.width(),map.height());
mapnik::request req(map.width(),map.height(),map.get_current_extent());
req.set_buffer_size(map.buffer_size());
mapnik::attributes vars;
@ -137,7 +137,7 @@ int main (int argc,char** argv)
}
}
}
mapnik::agg_renderer<mapnik::image_data_rgba8> ren(map,req,vars,im,scale_factor,0,0);
mapnik::agg_renderer<mapnik::image_rgba8> ren(map,req,vars,im,scale_factor,0,0);
ren.apply();
mapnik::save_to_file(im,img_file);
if (auto_open)

4
utils/svg2png/svg2png.cpp
View file

@ -157,7 +157,7 @@ int main (int argc,char** argv)
std::clog << "found width of '" << w << "' and height of '" << h << "'\n";
}
// 10 pixel buffer to avoid edge clipping of 100% svg's
mapnik::image_data_rgba8 im(w+0,h+0);
mapnik::image_rgba8 im(w+0,h+0);
agg::rendering_buffer buf(im.getBytes(), im.width(), im.height(), im.width() * 4);
pixfmt pixf(buf);
renderer_base renb(pixf);
@ -181,7 +181,7 @@ int main (int argc,char** argv)
boost::algorithm::ireplace_last(svg_name,".svg",".png");
demultiply_alpha(im);
mapnik::save_to_file<mapnik::image_data_rgba8>(im,svg_name,"png");
mapnik::save_to_file<mapnik::image_rgba8>(im,svg_name,"png");
if (auto_open)
{
std::ostringstream s;