{

std::string s = mapnik::save_to_string(im, format);

return py::bytes(s.data(), s.length());

{

std::string s = mapnik::save_to_string(im, format, pal);

return py::bytes(s.data(), s.length());

{

get_pixel_visitor(unsigned x, unsigned y)

: x_(x), y_(y) {}

py::object operator() (mapnik::image_null const&)

{

throw std::runtime_error("Can not return a null image from a pixel (shouldn't have reached here)");

}

template <typename T>

py::object operator() (T const& im)

{

using pixel_type = typename T::pixel_type;

using python_type = typename std::conditional<std::is_integral<pixel_type>::value, py::int_, py::float_>::type;

return python_type(mapnik::get_pixel<pixel_type>(im, x_, y_));

}

private:

unsigned x_;

unsigned y_;

{

if (x < 0 || x >= static_cast<int>(im.width()) ||

y < 0 || y >= static_cast<int>(im.height()))

{

throw std::out_of_range("invalid x,y for image dimensions");

}

return mapnik::util::apply_visitor(get_pixel_visitor(x, y), im);

{

if (x < 0 || x >= static_cast<int>(im.width()) ||

y < 0 || y >= static_cast<int>(im.height()))

{

throw std::out_of_range("invalid x,y for image dimensions");

}

return mapnik::get_pixel<mapnik::color>(im, x, y);

{

if (x < 0 || x >= static_cast<int>(im.width()) ||

y < 0 || y >= static_cast<int>(im.height()))

{

throw std::out_of_range("invalid x,y for image dimensions");

}

mapnik::set_pixel(im, x, y, c);

{

auto type = type_from_filename(filename);

if (type)

{

std::unique_ptr<image_reader> reader(get_image_reader(filename,*type));

if (reader.get())

{

return std::make_shared<image_any>(reader->read(0,0,reader->width(),reader->height()));

}

throw mapnik::image_reader_exception("Failed to load: " + filename);

}

throw mapnik::image_reader_exception("Unsupported image format:" + filename);

{

auto filename = args[0].cast<std::string>();

std::uint32_t x0 = args[1].cast<std::uint32_t>();

std::uint32_t y0 = args[2].cast<std::uint32_t>();

std::uint32_t width = args[3].cast<std::uint32_t>();

std::uint32_t height = args[4].cast<std::uint32_t>();

auto type = type_from_filename(filename);

if (type)

{

std::unique_ptr<image_reader> reader(get_image_reader(filename,*type));

if (reader.get())

{

return std::make_shared<image_any>(reader->read(x0, y0, width, height));

}

throw mapnik::image_reader_exception("Failed to load: " + filename);

}

throw mapnik::image_reader_exception("Unsupported image format:" + filename);

{

std::unique_ptr<image_reader> reader(get_image_reader(str.c_str(),str.size()));

if (reader.get())

{

return std::make_shared<image_any>(reader->read(0,0,reader->width(), reader->height()));

}

throw mapnik::image_reader_exception("Failed to load image from String" );

{

std::string_view view = std::string_view(obj);

std::unique_ptr<image_reader> reader

(get_image_reader(reinterpret_cast<char const*>(view.data()), view.length()));

if (reader.get())

{

return std::make_shared<image_any>(reader->read(0, 0, reader->width(), reader->height()));

}

throw mapnik::image_reader_exception("Failed to load image from Buffer" );

{

auto buf = py::buffer(memview);

py::buffer_info info = buf.request();

std::unique_ptr<image_reader> reader

(get_image_reader(reinterpret_cast<char const*>(info.ptr), info.size));

if (reader.get())

{

return std::make_shared<image_any>(reader->read(0, 0, reader->width(), reader->height()));

}

throw mapnik::image_reader_exception("Failed to load image from Buffer" );

{

bool demultiply_dst = mapnik::premultiply_alpha(dst);

bool demultiply_src = mapnik::premultiply_alpha(src);

mapnik::composite(dst,src,mode,opacity,dx,dy);

if (demultiply_dst)

{

mapnik::demultiply_alpha(dst);

}

if (demultiply_src)

{

mapnik::demultiply_alpha(src);

}

{

py::object ImageSurface = py::module_::import("cairo").attr("ImageSurface");

py::object get_width = ImageSurface.attr("get_width");

py::object get_height = ImageSurface.attr("get_height");

py::object get_format = ImageSurface.attr("get_format");

py::object get_data = ImageSurface.attr("get_data");

int format = py::int_(get_format(surface));

int width = py::int_(get_width(surface));

int height = py::int_(get_height(surface));

if (format == 0 ) // cairo.Format.ARGB32

{

mapnik::image_rgba8 image{width, height};

py::memoryview view = get_data(surface);

auto buf = py::buffer(view);

py::buffer_info info = buf.request();

const std::unique_ptr<unsigned int[]> out_row(new unsigned int[width]);

unsigned int const* in_row = reinterpret_cast<unsigned int const*>(info.ptr);

for (int row = 0; row < height; row++, in_row += width)

{

for (int column = 0; column < width; column++)

{

unsigned int in = in_row[column];

unsigned int a = (in >> 24) & 0xff;

unsigned int r = (in >> 16) & 0xff;

unsigned int g = (in >> 8) & 0xff;

unsigned int b = (in >> 0) & 0xff;

out_row[column] = mapnik::color(r, g, b, a).rgba();

}

image.set_row(row, out_row.get(), width);

}

return std::make_shared<image_any>(std::move(image));

}

else if (format == 1 ) // cairo.Format.RGB24

{

mapnik::image_rgba8 image{width, height};

py::memoryview view = get_data(surface);

auto buf = py::buffer(view);

py::buffer_info info = buf.request();

const std::unique_ptr<unsigned int[]> out_row(new unsigned int[width]);

unsigned int const* in_row = reinterpret_cast<unsigned int const*>(info.ptr);

for (int row = 0; row < height; row++, in_row += width)

{

for (int column = 0; column < width; column++)

{

unsigned int in = in_row[column];

unsigned int r = (in >> 16) & 0xff;

unsigned int g = (in >> 8) & 0xff;

unsigned int b = (in >> 0) & 0xff;

out_row[column] = mapnik::color(r, g, b, 255).rgba();

}

image.set_row(row, out_row.get(), width);

}

return std::make_shared<image_any>(std::move(image));

}

throw std::runtime_error("Unable to convert this Cairo format to rgba8 image");

{

py::native_enum<mapnik::image_dtype>(m, "ImageType", "enum.Enum")

.value("rgba8", mapnik::image_dtype_rgba8)

.value("gray8", mapnik::image_dtype_gray8)

.value("gray8s", mapnik::image_dtype_gray8s)

.value("gray16", mapnik::image_dtype_gray16)

.value("gray16s", mapnik::image_dtype_gray16s)

.value("gray32", mapnik::image_dtype_gray32)

.value("gray32s", mapnik::image_dtype_gray32s)

.value("gray32f", mapnik::image_dtype_gray32f)

.value("gray64", mapnik::image_dtype_gray64)

.value("gray64s", mapnik::image_dtype_gray64s)

.value("gray64f", mapnik::image_dtype_gray64f)

.finalize()

;

py::class_<image_any,std::shared_ptr<image_any>>(m, "Image","This class represents a image.")

.def(py::init<int,int>())

.def(py::init<int,int,mapnik::image_dtype>())

.def(py::init<int,int,mapnik::image_dtype,bool>())

.def(py::init<int,int,mapnik::image_dtype,bool,bool>())

.def(py::init<int,int,mapnik::image_dtype,bool,bool,bool>())

.def("width",&image_any::width)

.def("height",&image_any::height)

.def("view",&get_view)

.def("painted",&image_any::painted)

.def("is_solid",&is_solid)

.def("fill",&fill_color)

.def("fill",&fill_int)

.def("fill",&fill_double)

.def("set_grayscale_to_alpha",&set_grayscale_to_alpha, "Set the grayscale values to the alpha channel of the Image")

.def("set_grayscale_to_alpha",&set_grayscale_to_alpha_c, "Set the grayscale values to the alpha channel of the Image")

.def("set_color_to_alpha",&set_color_to_alpha, "Set a given color to the alpha channel of the Image")

.def("apply_opacity",&apply_opacity, "Set the opacity of the Image relative to the current alpha of each pixel.")

.def("composite",&composite,

py::arg("image"),

py::arg("mode") = mapnik::src_over,

py::arg("opacity") = 1.0f,

py::arg("dx") = 0,

py::arg("dy") = 0

)

.def("compare",&compare,

py::arg("image"),

py::arg("threshold")=0.0,

py::arg("alpha")=true

)

.def("copy",&copy,

py::arg("type"),

py::arg("offset")=0.0,

py::arg("scaling")=1.0

)

.def_property("offset",

&image_any::get_offset,

&image_any::set_offset,

"Gets or sets the offset component.\n")

.def_property("scaling",

&image_any::get_scaling,

&image_any::set_scaling,

"Gets or sets the offset component.\n")

.def("premultiplied",&premultiplied)

.def("premultiply",&premultiply)

.def("demultiply",&demultiply)

.def("set_pixel",&set_pixel<mapnik::color>)

.def("set_pixel",&set_pixel<double>)

.def("set_pixel",&set_pixel<int>)

.def("get_pixel_color",&get_pixel_color,

py::arg("x"), py::arg("y"))

.def("get_pixel", &get_pixel)

.def("get_type",&get_type)

.def("clear",&clear)

.def("to_string",&to_string1)

.def("to_string",&to_string2)

.def("to_string",&to_string3)

.def("save", &save_to_file1)

.def("save", &save_to_file2)

.def("save", &save_to_file3)

.def_static("open",open_from_file)

.def_static("open",open_from_file2)

.def_static("from_buffer",&from_buffer)

.def_static("from_memoryview",&from_memoryview)

.def_static("from_string",&from_string)

.def_static("from_cairo",&from_cairo)

;