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

Move image_data.hpp to image.hpp and renamed most everything from image_data to image alone. This might lead to the need to clean up some variables that are currently named image through out the code at some time, but I think in the long term is much better as image is a better name for the base class.

Browse source
This commit is contained in:
Blake Thompson 2015-01-22 11:39:37 -06:00
parent e353225772
commit 51172c8fdf
43 changed files with 122 additions and 122 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
benchmark/compare_images.hpp
View file

@ -2,7 +2,7 @@
#define __MAPNIK_COMPARE_IMAGES_HPP__ #define __MAPNIK_COMPARE_IMAGES_HPP__
#include <mapnik/graphics.hpp> #include <mapnik/graphics.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/image_reader.hpp> #include <mapnik/image_reader.hpp>

2
bindings/python/mapnik_image_view.cpp
View file

@ -35,7 +35,7 @@
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
// mapnik // mapnik
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>
#include <mapnik/image_view_any.hpp> #include <mapnik/image_view_any.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>

2
include/mapnik/agg_pattern_source.hpp
View file

@ -24,7 +24,7 @@
#define MAPNIK_AGG_PATTERN_SOURCE_HPP #define MAPNIK_AGG_PATTERN_SOURCE_HPP
// mapnik // mapnik
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/util/noncopyable.hpp> #include <mapnik/util/noncopyable.hpp>
// agg // agg

2
include/mapnik/agg_renderer.hpp
View file

@ -36,7 +36,7 @@
#include <mapnik/request.hpp> #include <mapnik/request.hpp>
#include <mapnik/symbolizer_enumerations.hpp> #include <mapnik/symbolizer_enumerations.hpp>
#include <mapnik/renderer_common.hpp> #include <mapnik/renderer_common.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
// stl // stl
#include <memory> #include <memory>

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

@ -27,7 +27,7 @@
// mapnik // mapnik
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/color.hpp> #include <mapnik/color.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
#include <mapnik/image_compositing.hpp> #include <mapnik/image_compositing.hpp>
#include <mapnik/font_engine_freetype.hpp> #include <mapnik/font_engine_freetype.hpp>

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

@ -25,7 +25,7 @@
#define MAPNIK_CAIRO_IMAGE_UTIL_HPP #define MAPNIK_CAIRO_IMAGE_UTIL_HPP
// mapnik // mapnik
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/cairo/cairo_context.hpp> // for cairo_surface_ptr #include <mapnik/cairo/cairo_context.hpp> // for cairo_surface_ptr
// stl // stl

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

@ -25,7 +25,7 @@
// mapnik // mapnik
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/grid/grid_view.hpp> #include <mapnik/grid/grid_view.hpp>
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
@ -50,7 +50,7 @@ class MAPNIK_DECL hit_grid
{ {
public: public:
using value_type = T; using value_type = T;
using data_type = mapnik::image_data<value_type>; using data_type = mapnik::image<value_type>;
using lookup_type = std::string; using lookup_type = std::string;
// mapping between pixel id and key // mapping between pixel id and key
using feature_key_type = std::map<value_type, lookup_type>; using feature_key_type = std::map<value_type, lookup_type>;

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

@ -23,7 +23,7 @@
#ifndef MAPNIK_GRID_VIEW_HPP #ifndef MAPNIK_GRID_VIEW_HPP
#define MAPNIK_GRID_VIEW_HPP #define MAPNIK_GRID_VIEW_HPP
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/value.hpp> #include <mapnik/value.hpp>
@ -196,7 +196,7 @@ private:
feature_type const& features_; feature_type const& features_;
}; };
using grid_view = hit_grid_view<mapnik::image_data<mapnik::value_integer> >; using grid_view = hit_grid_view<mapnik::image<mapnik::value_integer> >;
} }

20
include/mapnik/image_data.hpp → include/mapnik/image.hpp
View file

@ -116,13 +116,13 @@ struct image_dimensions
} }
template <typename T, std::size_t max_size = 65535> template <typename T, std::size_t max_size = 65535>
class image_data class image
{ {
public: public:
using pixel_type = T; using pixel_type = T;
static constexpr std::size_t pixel_size = sizeof(pixel_type); static constexpr std::size_t pixel_size = sizeof(pixel_type);
image_data(int width, int height, bool initialize = true, bool premultiplied = false, bool painted = false) image(int width, int height, bool initialize = true, bool premultiplied = false, bool painted = false)
: dimensions_(width, height), : dimensions_(width, height),
buffer_(dimensions_.width() * dimensions_.height() * pixel_size), buffer_(dimensions_.width() * dimensions_.height() * pixel_size),
pData_(reinterpret_cast<pixel_type*>(buffer_.data())), pData_(reinterpret_cast<pixel_type*>(buffer_.data())),
@ -132,7 +132,7 @@ public:
if (pData_ && initialize) std::fill(pData_, pData_ + dimensions_.width() * dimensions_.height(), 0); if (pData_ && initialize) std::fill(pData_, pData_ + dimensions_.width() * dimensions_.height(), 0);
} }
image_data(image_data<pixel_type> const& rhs) image(image<pixel_type> const& rhs)
: dimensions_(rhs.dimensions_), : dimensions_(rhs.dimensions_),
buffer_(rhs.buffer_), buffer_(rhs.buffer_),
pData_(reinterpret_cast<pixel_type*>(buffer_.data())), pData_(reinterpret_cast<pixel_type*>(buffer_.data())),
@ -140,7 +140,7 @@ public:
painted_(rhs.painted_) painted_(rhs.painted_)
{} {}
image_data(image_data<pixel_type> && rhs) noexcept image(image<pixel_type> && rhs) noexcept
: dimensions_(std::move(rhs.dimensions_)), : dimensions_(std::move(rhs.dimensions_)),
buffer_(std::move(rhs.buffer_)), buffer_(std::move(rhs.buffer_)),
pData_(reinterpret_cast<pixel_type*>(buffer_.data())), pData_(reinterpret_cast<pixel_type*>(buffer_.data())),
@ -151,13 +151,13 @@ public:
rhs.pData_ = nullptr; rhs.pData_ = nullptr;
} }
image_data<pixel_type>& operator=(image_data<pixel_type> rhs) image<pixel_type>& operator=(image<pixel_type> rhs)
{ {
swap(rhs); swap(rhs);
return *this; return *this;
} }
void swap(image_data<pixel_type> & rhs) void swap(image<pixel_type> & rhs)
{ {
std::swap(dimensions_, rhs.dimensions_); std::swap(dimensions_, rhs.dimensions_);
std::swap(buffer_, rhs.buffer_); std::swap(buffer_, rhs.buffer_);
@ -277,10 +277,10 @@ private:
bool painted_; bool painted_;
}; };
using image_rgba8 = image_data<std::uint32_t>; using image_rgba8 = image<std::uint32_t>;
using image_gray8 = image_data<std::uint8_t> ; using image_gray8 = image<std::uint8_t> ;
using image_gray16 = image_data<std::int16_t>; using image_gray16 = image<std::int16_t>;
using image_gray32f = image_data<float>; using image_gray32f = image<float>;
enum image_dtype : std::uint8_t enum image_dtype : std::uint8_t
{ {

16
include/mapnik/image_any.hpp
View file

@ -23,7 +23,7 @@
#ifndef MAPNIK_IMAGE_DATA_ANY_HPP #ifndef MAPNIK_IMAGE_DATA_ANY_HPP
#define MAPNIK_IMAGE_DATA_ANY_HPP #define MAPNIK_IMAGE_DATA_ANY_HPP
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/util/variant.hpp> #include <mapnik/util/variant.hpp>
namespace mapnik { namespace mapnik {
@ -40,18 +40,18 @@ struct image_null
bool painted() const { return false; } bool painted() const { return false; }
bool get_premultiplied() const { return false; } bool get_premultiplied() const { return false; }
void set_premultiplied(bool) const {} void set_premultiplied(bool) const {}
void set(pixel_type const&) { throw std::runtime_error("Can not set values for null image_data"); } void set(pixel_type const&) { throw std::runtime_error("Can not set values for null image"); }
pixel_type& operator() (std::size_t, std::size_t) pixel_type& operator() (std::size_t, std::size_t)
{ {
throw std::runtime_error("Can not set or get values for null image_data"); throw std::runtime_error("Can not set or get values for null image");
} }
pixel_type const& operator() (std::size_t, std::size_t) const pixel_type const& operator() (std::size_t, std::size_t) const
{ {
throw std::runtime_error("Can not set or get values for null image_data"); throw std::runtime_error("Can not set or get values for null image");
} }
}; };
using image_data_base = util::variant<image_null, using image_base = util::variant<image_null,
image_rgba8, image_rgba8,
image_gray8, image_gray8,
image_gray16, image_gray16,
@ -141,7 +141,7 @@ struct get_any_row_size_visitor
}; };
} // namespace detail } // namespace detail
struct image_any : image_data_base struct image_any : image_base
{ {
image_any() = default; image_any() = default;
@ -151,11 +151,11 @@ struct image_any : image_data_base
bool initialize = true, bool initialize = true,
bool premultiplied = false, bool premultiplied = false,
bool painted = false) bool painted = false)
: image_data_base(std::move(create_image_any(width, height, type, initialize, premultiplied, painted))) {} : image_base(std::move(create_image_any(width, height, type, initialize, premultiplied, painted))) {}
template <typename T> template <typename T>
image_any(T && data) noexcept image_any(T && data) noexcept
: image_data_base(std::move(data)) {} : image_base(std::move(data)) {}
unsigned char const* getBytes() const unsigned char const* getBytes() const
{ {

2
include/mapnik/image_compositing.hpp
View file

@ -24,7 +24,7 @@
#define MAPNIK_IMAGE_COMPOSITING_HPP #define MAPNIK_IMAGE_COMPOSITING_HPP
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>

2
include/mapnik/image_scaling.hpp
View file

@ -25,7 +25,7 @@
// mapnik // mapnik
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
// stl // stl
#include <iosfwd> #include <iosfwd>

2
include/mapnik/image_util.hpp
View file

@ -25,7 +25,7 @@
// mapnik // mapnik
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>
#include <mapnik/image_view_any.hpp> #include <mapnik/image_view_any.hpp>

2
include/mapnik/marker.hpp
View file

@ -24,7 +24,7 @@
#define MAPNIK_MARKER_HPP #define MAPNIK_MARKER_HPP
// mapnik // mapnik
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/svg/svg_storage.hpp> #include <mapnik/svg/svg_storage.hpp>
#include <mapnik/svg/svg_path_attributes.hpp> #include <mapnik/svg/svg_path_attributes.hpp>

2
include/mapnik/miniz_png.hpp
View file

@ -32,7 +32,7 @@
#include <iostream> #include <iostream>
#include <stdexcept> #include <stdexcept>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>
/* miniz.c porting issues: /* miniz.c porting issues:

2
include/mapnik/png_io.hpp
View file

@ -28,7 +28,7 @@
#include <mapnik/octree.hpp> #include <mapnik/octree.hpp>
#include <mapnik/hextree.hpp> #include <mapnik/hextree.hpp>
#include <mapnik/miniz_png.hpp> #include <mapnik/miniz_png.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
// zlib // zlib
#include <zlib.h> // for Z_DEFAULT_COMPRESSION #include <zlib.h> // for Z_DEFAULT_COMPRESSION

2
include/mapnik/raster_colorizer.hpp
View file

@ -40,7 +40,7 @@
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/color.hpp> #include <mapnik/color.hpp>
#include <mapnik/enumeration.hpp> #include <mapnik/enumeration.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>
// boost // boost

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

@ -45,10 +45,10 @@ namespace mapnik {
namespace detail { namespace detail {
template <typename F> template <typename F>
struct image_data_dispatcher struct image_dispatcher
{ {
using composite_function = F; using composite_function = F;
image_data_dispatcher(int start_x, int start_y, image_dispatcher(int start_x, int start_y,
int width, int height, int width, int height,
double scale_x, double scale_y, double scale_x, double scale_y,
scaling_method_e method, double filter_factor, scaling_method_e method, double filter_factor,
@ -80,8 +80,8 @@ struct image_data_dispatcher
template <typename T> template <typename T>
void operator() (T const& data_in) const void operator() (T const& data_in) const
{ {
using image_data_type = T; using image_type = T;
image_data_type data_out(width_, height_); image_type data_out(width_, height_);
scale_image_agg(data_out, data_in, method_, scale_x_, scale_y_, 0.0, 0.0, filter_factor_); scale_image_agg(data_out, data_in, method_, scale_x_, scale_y_, 0.0, 0.0, filter_factor_);
image_rgba8 dst(width_, height_); image_rgba8 dst(width_, height_);
raster_colorizer_ptr colorizer = get<raster_colorizer_ptr>(sym_, keys::colorizer); raster_colorizer_ptr colorizer = get<raster_colorizer_ptr>(sym_, keys::colorizer);
@ -107,10 +107,10 @@ private:
}; };
template <typename F> template <typename F>
struct image_data_warp_dispatcher struct image_warp_dispatcher
{ {
using composite_function = F; using composite_function = F;
image_data_warp_dispatcher(proj_transform const& prj_trans, image_warp_dispatcher(proj_transform const& prj_trans,
int start_x, int start_y, int width, int height, int start_x, int start_y, int width, int height,
box2d<double> const& target_ext, box2d<double> const& source_ext, box2d<double> const& target_ext, box2d<double> const& source_ext,
double offset_x, double offset_y, unsigned mesh_size, scaling_method_e scaling_method, double offset_x, double offset_y, unsigned mesh_size, scaling_method_e scaling_method,
@ -147,8 +147,8 @@ struct image_data_warp_dispatcher
template <typename T> template <typename T>
void operator() (T const& data_in) const void operator() (T const& data_in) const
{ {
using image_data_type = T; using image_type = T;
image_data_type data_out(width_, height_); image_type data_out(width_, height_);
if (nodata_) data_out.set(*nodata_); 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_); warp_image(data_out, data_in, prj_trans_, target_ext_, source_ext_, offset_x_, offset_y_, mesh_size_, scaling_method_, filter_factor_);
image_rgba8 dst(width_, height_); image_rgba8 dst(width_, height_);
@ -220,7 +220,7 @@ void render_raster_symbolizer(raster_symbolizer const& sym,
double offset_x = ext.minx() - start_x; double offset_x = ext.minx() - start_x;
double offset_y = ext.miny() - start_y; double offset_y = ext.miny() - start_y;
unsigned mesh_size = static_cast<unsigned>(get<value_integer>(sym,keys::mesh_size,feature, common.vars_, 16)); unsigned mesh_size = static_cast<unsigned>(get<value_integer>(sym,keys::mesh_size,feature, common.vars_, 16));
detail::image_data_warp_dispatcher<F> dispatcher(prj_trans, start_x, start_y, raster_width, raster_height, detail::image_warp_dispatcher<F> dispatcher(prj_trans, start_x, start_y, raster_width, raster_height,
target_ext, source->ext_, offset_x, offset_y, mesh_size, target_ext, source->ext_, offset_x, offset_y, mesh_size,
scaling_method, source->get_filter_factor(), scaling_method, source->get_filter_factor(),
opacity, comp_op, sym, feature, composite, source->nodata()); opacity, comp_op, sym, feature, composite, source->nodata());
@ -243,7 +243,7 @@ void render_raster_symbolizer(raster_symbolizer const& sym,
} }
else else
{ {
detail::image_data_dispatcher<F> dispatcher(start_x, start_y, raster_width, raster_height, detail::image_dispatcher<F> dispatcher(start_x, start_y, raster_width, raster_height,
image_ratio_x, image_ratio_y, image_ratio_x, image_ratio_y,
scaling_method, source->get_filter_factor(), scaling_method, source->get_filter_factor(),
opacity, comp_op, sym, feature, composite, source->nodata()); opacity, comp_op, sym, feature, composite, source->nodata());

2
include/mapnik/renderer_common/render_pattern.hpp
View file

@ -23,7 +23,7 @@
#ifndef MAPNIK_RENDER_PATTERN_HPP #ifndef MAPNIK_RENDER_PATTERN_HPP
#define MAPNIK_RENDER_PATTERN_HPP #define MAPNIK_RENDER_PATTERN_HPP
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <memory> #include <memory>
// fwd decl // fwd decl

8
include/mapnik/tiff_io.hpp
View file

@ -387,7 +387,7 @@ void save_as_tiff(T1 & file, T2 const& image, tiff_config & config)
TIFFSetField(output, TIFFTAG_TILELENGTH, tile_height); TIFFSetField(output, TIFFTAG_TILELENGTH, tile_height);
TIFFSetField(output, TIFFTAG_TILEDEPTH, 1); TIFFSetField(output, TIFFTAG_TILEDEPTH, 1);
std::size_t tile_size = tile_width * tile_height; std::size_t tile_size = tile_width * tile_height;
std::unique_ptr<pixel_type[]> image_data_out (new pixel_type[tile_size]); std::unique_ptr<pixel_type[]> image_out (new pixel_type[tile_size]);
int end_y = (height / tile_height + 1) * tile_height; int end_y = (height / tile_height + 1) * tile_height;
int end_x = (width / tile_width + 1) * tile_width; int end_x = (width / tile_width + 1) * tile_width;
end_y = std::min(end_y, height); end_y = std::min(end_y, height);
@ -400,14 +400,14 @@ void save_as_tiff(T1 & file, T2 const& image, tiff_config & config)
for (int x = 0; x < end_x; x += tile_width) for (int x = 0; x < end_x; x += tile_width)
{ {
// Prefill the entire array with zeros. // Prefill the entire array with zeros.
std::fill(image_data_out.get(), image_data_out.get() + tile_size, 0); std::fill(image_out.get(), image_out.get() + tile_size, 0);
int tx1 = std::min(width, x + tile_width); int tx1 = std::min(width, x + tile_width);
int row = y; int row = y;
for (int ty = 0; ty < ty1; ++ty, ++row) for (int ty = 0; ty < ty1; ++ty, ++row)
{ {
std::copy(image.getRow(row, x), image.getRow(row, tx1), image_data_out.get() + ty * tile_width); std::copy(image.getRow(row, x), image.getRow(row, tx1), image_out.get() + ty * tile_width);
} }
if (TIFFWriteEncodedTile(output, TIFFComputeTile(output, x, y, 0, 0), image_data_out.get(), tile_size * sizeof(pixel_type)) == -1) if (TIFFWriteEncodedTile(output, TIFFComputeTile(output, x, y, 0, 0), image_out.get(), tile_size * sizeof(pixel_type)) == -1)
{ {
throw ImageWriterException("Could not write TIFF - TIFF Tile Write failed"); throw ImageWriterException("Could not write TIFF - TIFF Tile Write failed");
} }

24
include/mapnik/webp_io.hpp
View file

@ -24,7 +24,7 @@
#define MAPNIK_WEBP_IO_HPP #define MAPNIK_WEBP_IO_HPP
// mapnik // mapnik
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>
// webp // webp
@ -73,14 +73,14 @@ std::string webp_encoding_error(WebPEncodingError error)
} }
template <typename T2> template <typename T2>
inline int import_image_data(T2 const& image, inline int import_image(T2 const& im_in,
WebPPicture & pic, WebPPicture & pic,
bool alpha) bool alpha)
{ {
image_data<typename T2::pixel_type> const& data = image.data(); image<typename T2::pixel_type> const& data = im_in.data();
int stride = sizeof(typename T2::pixel_type) * image.width(); int stride = sizeof(typename T2::pixel_type) * im_in.width();
if (data.width() == image.width() && if (data.width() == im_in.width() &&
data.height() == image.height()) data.height() == im_in.height())
{ {
if (alpha) if (alpha)
{ {
@ -98,10 +98,10 @@ inline int import_image_data(T2 const& image,
else else
{ {
// need to copy: https://github.com/mapnik/mapnik/issues/2024 // need to copy: https://github.com/mapnik/mapnik/issues/2024
image_rgba8 im(image.width(),image.height()); image_rgba8 im(im_in.width(),im_in.height());
for (unsigned y = 0; y < image.height(); ++y) for (unsigned y = 0; y < im_in.height(); ++y)
{ {
typename T2::pixel_type const * row_from = image.getRow(y); typename T2::pixel_type const * row_from = im_in.getRow(y);
image_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); std::copy(row_from, row_from + stride, row_to);
} }
@ -121,7 +121,7 @@ inline int import_image_data(T2 const& image,
} }
template <> template <>
inline int import_image_data(image_rgba8 const& im, inline int import_image(image_rgba8 const& im,
WebPPicture & pic, WebPPicture & pic,
bool alpha) bool alpha)
{ {
@ -187,10 +187,10 @@ void save_as_webp(T1& file,
{ {
// different approach for lossy since ImportYUVAFromRGBA is needed // different approach for lossy since ImportYUVAFromRGBA is needed
// to prepare WebPPicture and working with view pixels is not viable // to prepare WebPPicture and working with view pixels is not viable
ok = import_image_data(image,pic,alpha); ok = import_image(image,pic,alpha);
} }
#else #else
ok = import_image_data(image,pic,alpha); ok = import_image(image,pic,alpha);
#endif #endif
if (!ok) if (!ok)
{ {

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

@ -24,7 +24,7 @@
#include <mapnik/make_unique.hpp> #include <mapnik/make_unique.hpp>
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/raster.hpp> #include <mapnik/raster.hpp>
#include <mapnik/view_transform.hpp> #include <mapnik/view_transform.hpp>
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>

2
plugins/input/pgraster/pgraster_featureset.cpp
View file

@ -38,7 +38,7 @@
#include <mapnik/feature_factory.hpp> #include <mapnik/feature_factory.hpp>
#include <mapnik/view_transform.hpp> #include <mapnik/view_transform.hpp>
#include <mapnik/raster.hpp> #include <mapnik/raster.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>
#include <mapnik/util/trim.hpp> #include <mapnik/util/trim.hpp>
#include <mapnik/global.hpp> // for int2net #include <mapnik/global.hpp> // for int2net

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

@ -32,7 +32,7 @@
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/view_transform.hpp> #include <mapnik/view_transform.hpp>
#include <mapnik/raster.hpp> #include <mapnik/raster.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>
#include <mapnik/util/trim.hpp> #include <mapnik/util/trim.hpp>
#include <mapnik/box2d.hpp> // for box2d #include <mapnik/box2d.hpp> // for box2d
@ -279,7 +279,7 @@ mapnik::raster_ptr read_grayscale_band(mapnik::box2d<double> const& bbox,
int val; int val;
uint8_t * data = image.getBytes(); uint8_t * data = image.getBytes();
int ps = 4; // sizeof(image_data::pixel_type) int ps = 4; // sizeof(image::pixel_type)
int off; int off;
val = reader(); // nodata value, need to read anyway val = reader(); // nodata value, need to read anyway
for (int y=0; y<height; ++y) { for (int y=0; y<height; ++y) {
@ -352,9 +352,9 @@ 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, mapnik::raster_ptr pgraster_wkb_reader::read_rgba(mapnik::box2d<double> const& bbox,
uint16_t width, uint16_t height) uint16_t width, uint16_t height)
{ {
mapnik::image_rgba8 image(width, height, true, true); mapnik::image_rgba8 im(width, height, true, true);
// Start with plain white (ABGR or RGBA depending on endiannes) // Start with plain white (ABGR or RGBA depending on endiannes)
image.set(0xffffffff); im.set(0xffffffff);
uint8_t nodataval; uint8_t nodataval;
for (int bn=0; bn<numBands_; ++bn) { for (int bn=0; bn<numBands_; ++bn) {
@ -387,8 +387,8 @@ mapnik::raster_ptr pgraster_wkb_reader::read_rgba(mapnik::box2d<double> const& b
<< " nodataval " << tmp << " != band 0 nodataval " << nodataval; << " nodataval " << tmp << " != band 0 nodataval " << nodataval;
} }
int ps = 4; // sizeof(image_data::pixel_type) int ps = 4; // sizeof(image::pixel_type)
uint8_t * image_data = image.getBytes(); uint8_t * image_data = im.getBytes();
for (int y=0; y<height_; ++y) { for (int y=0; y<height_; ++y) {
for (int x=0; x<width_; ++x) { for (int x=0; x<width_; ++x) {
uint8_t val = read_uint8(&ptr_); uint8_t val = read_uint8(&ptr_);
@ -400,7 +400,7 @@ mapnik::raster_ptr pgraster_wkb_reader::read_rgba(mapnik::box2d<double> const& b
} }
} }
} }
mapnik::raster_ptr raster = std::make_shared<mapnik::raster>(bbox, image, 1.0); mapnik::raster_ptr raster = std::make_shared<mapnik::raster>(bbox, im, 1.0);
raster->set_nodata(0xffffffff); raster->set_nodata(0xffffffff);
return raster; return raster;
} }

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

@ -22,7 +22,7 @@
// mapnik // mapnik
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/raster.hpp> #include <mapnik/raster.hpp>
#include <mapnik/view_transform.hpp> #include <mapnik/view_transform.hpp>
#include <mapnik/image_reader.hpp> #include <mapnik/image_reader.hpp>

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

@ -24,7 +24,7 @@
// mapnik // mapnik
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/query.hpp> #include <mapnik/query.hpp>
#include <mapnik/raster.hpp> #include <mapnik/raster.hpp>
@ -116,8 +116,8 @@ feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
{ {
mapnik::image_rgba8 image(width,height); mapnik::image_rgba8 image(width,height);
unsigned char* raster_data = static_cast<unsigned char*>(raster); unsigned char* raster_data = static_cast<unsigned char*>(raster);
unsigned char* image_data = image.getBytes(); unsigned char* image = image.getBytes();
std::memcpy(image_data, raster_data, size); std::memcpy(image, raster_data, size);
feature->set_raster(std::make_shared<mapnik::raster>(intersect, std::move(image), 1.0)); feature->set_raster(std::make_shared<mapnik::raster>(intersect, std::move(image), 1.0));
MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Done"; MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Done";
} }

2
src/agg/process_dot_symbolizer.cpp
View file

@ -26,7 +26,7 @@
#include <mapnik/agg_rasterizer.hpp> #include <mapnik/agg_rasterizer.hpp>
#include <mapnik/symbolizer.hpp> #include <mapnik/symbolizer.hpp>
#include <mapnik/symbolizer_keys.hpp> #include <mapnik/symbolizer_keys.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/vertex.hpp> #include <mapnik/vertex.hpp>
#include <mapnik/renderer_common.hpp> #include <mapnik/renderer_common.hpp>
#include <mapnik/proj_transform.hpp> #include <mapnik/proj_transform.hpp>

2
src/agg/process_group_symbolizer.cpp
View file

@ -26,7 +26,7 @@
#include <mapnik/agg_rasterizer.hpp> #include <mapnik/agg_rasterizer.hpp>
#include <mapnik/agg_render_marker.hpp> #include <mapnik/agg_render_marker.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/util/variant.hpp> #include <mapnik/util/variant.hpp>
#include <mapnik/text/renderer.hpp> #include <mapnik/text/renderer.hpp>
#include <mapnik/geom_util.hpp> #include <mapnik/geom_util.hpp>

2
src/agg/process_raster_symbolizer.cpp
View file

@ -28,7 +28,7 @@
#include <mapnik/symbolizer.hpp> #include <mapnik/symbolizer.hpp>
#include <mapnik/raster_colorizer.hpp> #include <mapnik/raster_colorizer.hpp>
#include <mapnik/agg_rasterizer.hpp> #include <mapnik/agg_rasterizer.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/raster.hpp> #include <mapnik/raster.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>

8
src/image_compositing.cpp
View file

@ -22,7 +22,7 @@
// mapnik // mapnik
#include <mapnik/image_compositing.hpp> #include <mapnik/image_compositing.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
// boost // boost
@ -129,8 +129,8 @@ namespace detail {
template <typename T> template <typename T>
struct rendering_buffer struct rendering_buffer
{ {
using image_data_type = T; using image_type = T;
using pixel_type = typename image_data_type::pixel_type; using pixel_type = typename image_type::pixel_type;
using row_data = agg::const_row_info<uint8_t>; using row_data = agg::const_row_info<uint8_t>;
rendering_buffer(T const& data) rendering_buffer(T const& data)
@ -143,7 +143,7 @@ struct rendering_buffer
uint8_t const* row_ptr(int, int y, unsigned) {return row_ptr(y);} uint8_t const* row_ptr(int, int y, unsigned) {return row_ptr(y);}
uint8_t const* row_ptr(int y) const { return reinterpret_cast<uint8_t const*>(data_.getRow(y)); } uint8_t const* row_ptr(int y) const { return reinterpret_cast<uint8_t const*>(data_.getRow(y)); }
row_data row (int y) const { return row_data(0, data_.width() - 1, row_ptr(y)); } row_data row (int y) const { return row_data(0, data_.width() - 1, row_ptr(y)); }
image_data_type const& data_; image_type const& data_;
}; };
} // end detail ns } // end detail ns

2
src/image_convert.cpp
View file

@ -22,7 +22,7 @@
// mapnik // mapnik
#include <mapnik/image_convert.hpp> #include <mapnik/image_convert.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
namespace mapnik namespace mapnik

18
src/image_scaling.cpp
View file

@ -21,7 +21,7 @@
*****************************************************************************/ *****************************************************************************/
// mapnik // mapnik
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_scaling.hpp> #include <mapnik/image_scaling.hpp>
#include <mapnik/image_scaling_traits.hpp> #include <mapnik/image_scaling_traits.hpp>
// does not handle alpha correctly // does not handle alpha correctly
@ -107,12 +107,12 @@ void scale_image_agg(T & target, T const& source, scaling_method_e scaling_metho
// http://old.nabble.com/Re:--AGG--Basic-image-transformations-p1110665.html // http://old.nabble.com/Re:--AGG--Basic-image-transformations-p1110665.html
// "Yes, you need to use premultiplied images only. Only in this case the simple weighted averaging works correctly in the image fitering." // "Yes, you need to use premultiplied images only. Only in this case the simple weighted averaging works correctly in the image fitering."
// http://permalink.gmane.org/gmane.comp.graphics.agg/3443 // http://permalink.gmane.org/gmane.comp.graphics.agg/3443
using image_data_type = T; using image_type = T;
using pixel_type = typename image_data_type::pixel_type; using pixel_type = typename image_type::pixel_type;
using pixfmt_pre = typename detail::agg_scaling_traits<image_data_type>::pixfmt_pre; using pixfmt_pre = typename detail::agg_scaling_traits<image_type>::pixfmt_pre;
using color_type = typename detail::agg_scaling_traits<image_data_type>::color_type; using color_type = typename detail::agg_scaling_traits<image_type>::color_type;
using img_src_type = typename detail::agg_scaling_traits<image_data_type>::img_src_type; using img_src_type = typename detail::agg_scaling_traits<image_type>::img_src_type;
using interpolator_type = typename detail::agg_scaling_traits<image_data_type>::interpolator_type; using interpolator_type = typename detail::agg_scaling_traits<image_type>::interpolator_type;
using renderer_base_pre = agg::renderer_base<pixfmt_pre>; using renderer_base_pre = agg::renderer_base<pixfmt_pre>;
constexpr std::size_t pixel_size = sizeof(pixel_type); constexpr std::size_t pixel_size = sizeof(pixel_type);
@ -150,13 +150,13 @@ void scale_image_agg(T & target, T const& source, scaling_method_e scaling_metho
if (scaling_method == SCALING_NEAR) if (scaling_method == SCALING_NEAR)
{ {
using span_gen_type = typename detail::agg_scaling_traits<image_data_type>::span_image_filter; using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_filter;
span_gen_type sg(img_src, interpolator); span_gen_type sg(img_src, interpolator);
agg::render_scanlines_aa(ras, sl, rb_dst_pre, sa, sg); agg::render_scanlines_aa(ras, sl, rb_dst_pre, sa, sg);
} }
else else
{ {
using span_gen_type = typename detail::agg_scaling_traits<image_data_type>::span_image_resample_affine; using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_resample_affine;
agg::image_filter_lut filter; agg::image_filter_lut filter;
detail::set_scaling_method(filter, scaling_method, filter_factor); detail::set_scaling_method(filter, scaling_method, filter_factor);
span_gen_type sg(img_src, interpolator, filter); span_gen_type sg(img_src, interpolator, filter);

2
src/image_util.cpp
View file

@ -26,7 +26,7 @@
#include <mapnik/image_util_png.hpp> #include <mapnik/image_util_png.hpp>
#include <mapnik/image_util_tiff.hpp> #include <mapnik/image_util_tiff.hpp>
#include <mapnik/image_util_webp.hpp> #include <mapnik/image_util_webp.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
#include <mapnik/image_view_any.hpp> #include <mapnik/image_view_any.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>

2
src/image_util_jpeg.cpp
View file

@ -27,7 +27,7 @@
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/image_util_jpeg.hpp> #include <mapnik/image_util_jpeg.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>

2
src/image_util_png.cpp
View file

@ -34,7 +34,7 @@ extern "C"
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/image_util_png.hpp> #include <mapnik/image_util_png.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>

2
src/image_util_tiff.cpp
View file

@ -27,7 +27,7 @@
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/image_util_tiff.hpp> #include <mapnik/image_util_tiff.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>

2
src/image_util_webp.cpp
View file

@ -27,7 +27,7 @@
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/image_util_webp.hpp> #include <mapnik/image_util_webp.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_any.hpp> #include <mapnik/image_any.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>

2
src/miniz_png.cpp
View file

@ -23,7 +23,7 @@
// mapnik // mapnik
#include <mapnik/palette.hpp> #include <mapnik/palette.hpp>
#include <mapnik/miniz_png.hpp> #include <mapnik/miniz_png.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_view.hpp> #include <mapnik/image_view.hpp>
// miniz // miniz

4
src/raster_colorizer.cpp
View file

@ -127,8 +127,8 @@ void raster_colorizer::colorize(image_rgba8 & out, T const& in,
boost::optional<double> const& nodata, boost::optional<double> const& nodata,
feature_impl const& f) const feature_impl const& f) const
{ {
using image_data_type = T; using image_type = T;
using pixel_type = typename image_data_type::pixel_type; using pixel_type = typename image_type::pixel_type;
// TODO: assuming in/out have the same width/height for now // TODO: assuming in/out have the same width/height for now
std::uint32_t * out_data = out.getData(); std::uint32_t * out_data = out.getData();
pixel_type const* in_data = in.getData(); pixel_type const* in_data = in.getData();

14
src/tiff_reader.cpp
View file

@ -397,12 +397,12 @@ template <typename T>
template <typename ImageData> template <typename ImageData>
image_any tiff_reader<T>::read_any_gray(unsigned x0, unsigned y0, unsigned width, unsigned height) image_any tiff_reader<T>::read_any_gray(unsigned x0, unsigned y0, unsigned width, unsigned height)
{ {
using image_data_type = ImageData; using image_type = ImageData;
using pixel_type = typename image_data_type::pixel_type; using pixel_type = typename image_type::pixel_type;
if (read_method_ == tiled) if (read_method_ == tiled)
{ {
image_data_type data(width,height); image_type data(width,height);
read_tiled<image_data_type>(x0, y0, data); read_tiled<image_type>(x0, y0, data);
return image_any(std::move(data)); return image_any(std::move(data));
} }
else else
@ -410,7 +410,7 @@ image_any tiff_reader<T>::read_any_gray(unsigned x0, unsigned y0, unsigned width
TIFF* tif = open(stream_); TIFF* tif = open(stream_);
if (tif) if (tif)
{ {
image_data_type data(width, height); image_type data(width, height);
std::size_t block_size = rows_per_strip_ > 0 ? rows_per_strip_ : tile_height_ ; std::size_t block_size = rows_per_strip_ > 0 ? rows_per_strip_ : tile_height_ ;
std::ptrdiff_t start_y = y0 - y0 % block_size; std::ptrdiff_t start_y = y0 - y0 % block_size;
std::ptrdiff_t end_y = std::min(y0 + height, static_cast<unsigned>(height_)); std::ptrdiff_t end_y = std::min(y0 + height, static_cast<unsigned>(height_));
@ -454,8 +454,8 @@ struct rgb8_to_rgba8
template <typename T> template <typename T>
struct tiff_reader_traits struct tiff_reader_traits
{ {
using image_data_type = T; using image_type = T;
using pixel_type = typename image_data_type::pixel_type; using pixel_type = typename image_type::pixel_type;
static bool read_tile(TIFF * tif, unsigned x, unsigned y, pixel_type* buf, std::size_t tile_width, std::size_t tile_height) static bool read_tile(TIFF * tif, unsigned x, unsigned y, pixel_type* buf, std::size_t tile_width, std::size_t tile_height)
{ {
return (TIFFReadEncodedTile(tif, TIFFComputeTile(tif, x,y,0,0), buf, tile_width * tile_height * sizeof(pixel_type)) != -1); return (TIFFReadEncodedTile(tif, TIFFComputeTile(tif, x,y,0,0), buf, tile_width * tile_height * sizeof(pixel_type)) != -1);

26
src/warp.cpp
View file

@ -23,7 +23,7 @@
// mapnik // mapnik
#include <mapnik/warp.hpp> #include <mapnik/warp.hpp>
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_scaling_traits.hpp> #include <mapnik/image_scaling_traits.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
@ -53,12 +53,12 @@ MAPNIK_DECL void warp_image (T & target, T const& source, proj_transform const&
box2d<double> const& target_ext, box2d<double> const& source_ext, box2d<double> const& target_ext, box2d<double> const& source_ext,
double offset_x, double offset_y, unsigned mesh_size, scaling_method_e scaling_method, double filter_factor) double offset_x, double offset_y, unsigned mesh_size, scaling_method_e scaling_method, double filter_factor)
{ {
using image_data_type = T; using image_type = T;
using pixel_type = typename image_data_type::pixel_type; using pixel_type = typename image_type::pixel_type;
using pixfmt_pre = typename detail::agg_scaling_traits<image_data_type>::pixfmt_pre; using pixfmt_pre = typename detail::agg_scaling_traits<image_type>::pixfmt_pre;
using color_type = typename detail::agg_scaling_traits<image_data_type>::color_type; using color_type = typename detail::agg_scaling_traits<image_type>::color_type;
using renderer_base = agg::renderer_base<pixfmt_pre>; using renderer_base = agg::renderer_base<pixfmt_pre>;
using interpolator_type = typename detail::agg_scaling_traits<image_data_type>::interpolator_type; using interpolator_type = typename detail::agg_scaling_traits<image_type>::interpolator_type;
constexpr std::size_t pixel_size = sizeof(pixel_type); constexpr std::size_t pixel_size = sizeof(pixel_type);
@ -70,8 +70,8 @@ MAPNIK_DECL void warp_image (T & target, T const& source, proj_transform const&
std::size_t mesh_nx = std::ceil(source.width()/double(mesh_size) + 1); std::size_t mesh_nx = std::ceil(source.width()/double(mesh_size) + 1);
std::size_t mesh_ny = std::ceil(source.height()/double(mesh_size) + 1); std::size_t mesh_ny = std::ceil(source.height()/double(mesh_size) + 1);
image_data<double> xs(mesh_nx, mesh_ny); image<double> xs(mesh_nx, mesh_ny);
image_data<double> ys(mesh_nx, mesh_ny); image<double> ys(mesh_nx, mesh_ny);
// Precalculate reprojected mesh // Precalculate reprojected mesh
for(std::size_t j = 0; j < mesh_ny; ++j) for(std::size_t j = 0; j < mesh_ny; ++j)
@ -138,13 +138,13 @@ MAPNIK_DECL void warp_image (T & target, T const& source, proj_transform const&
interpolator_type interpolator(tr); interpolator_type interpolator(tr);
if (scaling_method == SCALING_NEAR) if (scaling_method == SCALING_NEAR)
{ {
using span_gen_type = typename detail::agg_scaling_traits<image_data_type>::span_image_filter; using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_filter;
span_gen_type sg(ia, interpolator); span_gen_type sg(ia, interpolator);
agg::render_scanlines_bin(rasterizer, scanline, rb, sa, sg); agg::render_scanlines_bin(rasterizer, scanline, rb, sa, sg);
} }
else else
{ {
using span_gen_type = typename detail::agg_scaling_traits<image_data_type>::span_image_resample_affine; using span_gen_type = typename detail::agg_scaling_traits<image_type>::span_image_resample_affine;
agg::image_filter_lut filter; agg::image_filter_lut filter;
detail::set_scaling_method(filter, scaling_method, filter_factor); detail::set_scaling_method(filter, scaling_method, filter_factor);
span_gen_type sg(ia, interpolator, filter); span_gen_type sg(ia, interpolator, filter);
@ -177,11 +177,11 @@ struct warp_image_visitor
template <typename T> template <typename T>
void operator() (T const& source) void operator() (T const& source)
{ {
using image_data_type = T; using image_type = T;
//source and target image data types must match //source and target image data types must match
if (target_raster_.data_.template is<image_data_type>()) if (target_raster_.data_.template is<image_type>())
{ {
image_data_type & target = util::get<image_data_type>(target_raster_.data_); image_type & target = util::get<image_type>(target_raster_.data_);
warp_image (target, source, prj_trans_, target_raster_.ext_, source_ext_, warp_image (target, source, prj_trans_, target_raster_.ext_, source_ext_,
offset_x_, offset_y_, mesh_size_, scaling_method_, filter_factor_); offset_x_, offset_y_, mesh_size_, scaling_method_, filter_factor_);
} }

2
tests/cpp_tests/image_io_test.cpp
View file

@ -1,6 +1,6 @@
#include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_test.hpp>
#include <iostream> #include <iostream>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_reader.hpp> #include <mapnik/image_reader.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/util/fs.hpp> #include <mapnik/util/fs.hpp>

2
tests/cpp_tests/map_request_test.cpp
View file

@ -10,7 +10,7 @@
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/datasource_cache.hpp> #include <mapnik/datasource_cache.hpp>
#include <mapnik/font_engine_freetype.hpp> #include <mapnik/font_engine_freetype.hpp>
#include <mapnik/image_data.hpp> #include <mapnik/image.hpp>
#include <mapnik/image_reader.hpp> #include <mapnik/image_reader.hpp>
#include <mapnik/scale_denominator.hpp> #include <mapnik/scale_denominator.hpp>
#include <mapnik/feature_style_processor.hpp> #include <mapnik/feature_style_processor.hpp>