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

+ move compositing into core lib

Browse source
This commit is contained in:
Artem Pavlenko 2011-09-13 15:31:07 +00:00
parent c1a12f65c0
commit d5e57afac0
2 changed files with 223 additions and 179 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

213
bindings/python/mapnik_image.cpp
View file

@ -38,14 +38,10 @@ extern "C"
#include <mapnik/image_util.hpp>
#include <mapnik/png_io.hpp>
#include <mapnik/image_reader.hpp>
#include <sstream>
#include <mapnik/image_compositing.hpp>
// agg
#include "agg_rendering_buffer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_scanline_u.h"
#include "agg_renderer_scanline.h"
#include "agg_pixfmt_rgba.h"
// stl
#include <sstream>
// jpeg
#if defined(HAVE_JPEG)
@ -146,151 +142,10 @@ void blend (image_32 & im, unsigned x, unsigned y, image_32 const& im2, float op
im.set_rectangle_alpha2(im2.data(),x,y,opacity);
}
// Compositing modes
// http://www.w3.org/TR/2009/WD-SVGCompositing-20090430/
enum composite_mode_e
void composite(image_32 & im, image_32 & im2, mapnik::composite_mode_e mode)
{
clear = 1,
src,
dst,
src_over,
dst_over,
src_in,
dst_in,
src_out,
dst_out,
src_atop,
dst_atop,
_xor,
plus,
minus,
multiply,
screen,
overlay,
darken,
lighten,
color_dodge,
color_burn,
hard_light,
soft_light,
difference,
exclusion,
contrast,
invert,
invert_rgb
};
void composite(image_32 & im, image_32 & im2, composite_mode_e mode)
{
typedef agg::rgba8 color;
typedef agg::order_bgra order;
typedef agg::pixel32_type pixel_type;
typedef agg::comp_op_adaptor_rgba<color, order> blender_type;
typedef agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixfmt_type;
typedef agg::renderer_base<pixfmt_type> renderer_type;
typedef agg::comp_op_adaptor_rgba<color, order> blender_type;
typedef agg::renderer_base<pixfmt_type> renderer_type;
agg::rendering_buffer source(im.raw_data(),im.width(),im.height(),im.width() * 4);
agg::rendering_buffer mask(im2.raw_data(),im2.width(),im2.height(),im2.width() * 4);
agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixf(source);
agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixf_mask(mask);
switch(mode)
{
case clear :
pixf.comp_op(agg::comp_op_clear);
break;
case src:
pixf.comp_op(agg::comp_op_src);
break;
case dst:
pixf.comp_op(agg::comp_op_dst);
break;
case src_over:
pixf.comp_op(agg::comp_op_src_over);
break;
case dst_over:
pixf.comp_op(agg::comp_op_dst_over);
break;
case src_in:
pixf.comp_op(agg::comp_op_src_in);
break;
case dst_in:
pixf.comp_op(agg::comp_op_dst_in);
break;
case src_out:
pixf.comp_op(agg::comp_op_src_out);
break;
case dst_out:
pixf.comp_op(agg::comp_op_dst_out);
break;
case src_atop:
pixf.comp_op(agg::comp_op_src_atop);
break;
case dst_atop:
pixf.comp_op(agg::comp_op_dst_atop);
break;
case _xor:
pixf.comp_op(agg::comp_op_xor);
break;
case plus:
pixf.comp_op(agg::comp_op_plus);
break;
case minus:
pixf.comp_op(agg::comp_op_minus);
break;
case multiply:
pixf.comp_op(agg::comp_op_multiply);
break;
case screen:
pixf.comp_op(agg::comp_op_screen);
break;
case overlay:
pixf.comp_op(agg::comp_op_overlay);
break;
case darken:
pixf.comp_op(agg::comp_op_darken);
break;
case lighten:
pixf.comp_op(agg::comp_op_lighten);
break;
case color_dodge:
pixf.comp_op(agg::comp_op_color_dodge);
break;
case color_burn:
pixf.comp_op(agg::comp_op_color_burn);
break;
case hard_light:
pixf.comp_op(agg::comp_op_hard_light);
break;
case soft_light:
pixf.comp_op(agg::comp_op_soft_light);
break;
case difference:
pixf.comp_op(agg::comp_op_difference);
break;
case exclusion:
pixf.comp_op(agg::comp_op_exclusion);
break;
case contrast:
pixf.comp_op(agg::comp_op_contrast);
break;
case invert:
pixf.comp_op(agg::comp_op_invert);
break;
case invert_rgb:
pixf.comp_op(agg::comp_op_invert_rgb);
break;
default:
break;
}
renderer_type ren(pixf);
agg::renderer_base<pixfmt_type> rb(pixf);
rb.blend_from(pixf_mask,0,0,0,255);
mapnik::composite(im.data(),im2.data(),mode);
}
#if defined(HAVE_CAIRO) && defined(HAVE_PYCAIRO)
@ -305,35 +160,35 @@ boost::shared_ptr<image_32> from_cairo(PycairoSurface* surface)
void export_image()
{
using namespace boost::python;
enum_<composite_mode_e>("CompositeOp")
.value("clear",clear)
.value("src",src)
.value("dst",dst)
.value("src_over",src_over)
.value("dst_over",dst_over)
.value("src_in",src_in)
.value("dst_in",dst_in)
.value("src_out",src_out)
.value("dst_out",dst_out)
.value("src_atop",src_atop)
.value("dst_atop",dst_atop)
.value("xor",_xor)
.value("plus",plus)
.value("minus",minus)
.value("multiply",multiply)
.value("screen",screen)
.value("overlay",overlay)
.value("darken",darken)
.value("lighten",lighten)
.value("color_dodge",color_dodge)
.value("color_burn",color_burn)
.value("hard_light",hard_light)
.value("soft_light",soft_light)
.value("difference",difference)
.value("exclusion",exclusion)
.value("contrast",contrast)
.value("invert",invert)
.value("invert_rgb",invert_rgb)
enum_<mapnik::composite_mode_e>("CompositeOp")
.value("clear", mapnik::clear)
.value("src", mapnik::src)
.value("dst", mapnik::dst)
.value("src_over", mapnik::src_over)
.value("dst_over", mapnik::dst_over)
.value("src_in", mapnik::src_in)
.value("dst_in", mapnik::dst_in)
.value("src_out", mapnik::src_out)
.value("dst_out", mapnik::dst_out)
.value("src_atop", mapnik::src_atop)
.value("dst_atop", mapnik::dst_atop)
.value("xor", mapnik::_xor)
.value("plus", mapnik::plus)
.value("minus", mapnik::minus)
.value("multiply", mapnik::multiply)
.value("screen", mapnik::screen)
.value("overlay", mapnik::overlay)
.value("darken", mapnik::darken)
.value("lighten", mapnik::lighten)
.value("color_dodge", mapnik::color_dodge)
.value("color_burn", mapnik::color_burn)
.value("hard_light", mapnik::hard_light)
.value("soft_light", mapnik::soft_light)
.value("difference", mapnik::difference)
.value("exclusion", mapnik::exclusion)
.value("contrast", mapnik::contrast)
.value("invert", mapnik::invert)
.value("invert_rgb", mapnik::invert_rgb)
;
class_<image_32,boost::shared_ptr<image_32> >("Image","This class represents a 32 bit RGBA image.",init<int,int>())

189
include/mapnik/image_compositing.hpp Normal file
View file

@ -0,0 +1,189 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2011 Artem Pavlenko
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*****************************************************************************/
//$Id$
#ifndef IMAGE_COMPOSITING_HPP
#define IMAGE_COMPOSITING_HPP
// agg
#include "agg_rendering_buffer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_scanline_u.h"
#include "agg_renderer_scanline.h"
#include "agg_pixfmt_rgba.h"
namespace mapnik
{
// Compositing modes
// http://www.w3.org/TR/2009/WD-SVGCompositing-20090430/
enum composite_mode_e
{
clear = 1,
src,
dst,
src_over,
dst_over,
src_in,
dst_in,
src_out,
dst_out,
src_atop,
dst_atop,
_xor,
plus,
minus,
multiply,
screen,
overlay,
darken,
lighten,
color_dodge,
color_burn,
hard_light,
soft_light,
difference,
exclusion,
contrast,
invert,
invert_rgb
};
template <typename T1, typename T2>
void composite(T1 & im, T2 & im2, composite_mode_e mode)
{
typedef agg::rgba8 color;
typedef agg::order_bgra order;
typedef agg::pixel32_type pixel_type;
typedef agg::comp_op_adaptor_rgba<color, order> blender_type;
typedef agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixfmt_type;
typedef agg::renderer_base<pixfmt_type> renderer_type;
typedef agg::comp_op_adaptor_rgba<color, order> blender_type;
typedef agg::renderer_base<pixfmt_type> renderer_type;
agg::rendering_buffer source(im.getBytes(),im.width(),im.height(),im.width() * 4);
agg::rendering_buffer mask(im2.getBytes(),im2.width(),im2.height(),im2.width() * 4);
agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixf(source);
agg::pixfmt_custom_blend_rgba<blender_type, agg::rendering_buffer> pixf_mask(mask);
switch(mode)
{
case clear :
pixf.comp_op(agg::comp_op_clear);
break;
case src:
pixf.comp_op(agg::comp_op_src);
break;
case dst:
pixf.comp_op(agg::comp_op_dst);
break;
case src_over:
pixf.comp_op(agg::comp_op_src_over);
break;
case dst_over:
pixf.comp_op(agg::comp_op_dst_over);
break;
case src_in:
pixf.comp_op(agg::comp_op_src_in);
break;
case dst_in:
pixf.comp_op(agg::comp_op_dst_in);
break;
case src_out:
pixf.comp_op(agg::comp_op_src_out);
break;
case dst_out:
pixf.comp_op(agg::comp_op_dst_out);
break;
case src_atop:
pixf.comp_op(agg::comp_op_src_atop);
break;
case dst_atop:
pixf.comp_op(agg::comp_op_dst_atop);
break;
case _xor:
pixf.comp_op(agg::comp_op_xor);
break;
case plus:
pixf.comp_op(agg::comp_op_plus);
break;
case minus:
pixf.comp_op(agg::comp_op_minus);
break;
case multiply:
pixf.comp_op(agg::comp_op_multiply);
break;
case screen:
pixf.comp_op(agg::comp_op_screen);
break;
case overlay:
pixf.comp_op(agg::comp_op_overlay);
break;
case darken:
pixf.comp_op(agg::comp_op_darken);
break;
case lighten:
pixf.comp_op(agg::comp_op_lighten);
break;
case color_dodge:
pixf.comp_op(agg::comp_op_color_dodge);
break;
case color_burn:
pixf.comp_op(agg::comp_op_color_burn);
break;
case hard_light:
pixf.comp_op(agg::comp_op_hard_light);
break;
case soft_light:
pixf.comp_op(agg::comp_op_soft_light);
break;
case difference:
pixf.comp_op(agg::comp_op_difference);
break;
case exclusion:
pixf.comp_op(agg::comp_op_exclusion);
break;
case contrast:
pixf.comp_op(agg::comp_op_contrast);
break;
case invert:
pixf.comp_op(agg::comp_op_invert);
break;
case invert_rgb:
pixf.comp_op(agg::comp_op_invert_rgb);
break;
default:
break;
}
renderer_type ren(pixf);
agg::renderer_base<pixfmt_type> rb(pixf);
rb.blend_from(pixf_mask,0,0,0,255);
}
}
#endif // IMAGE_COMPOSITING_HPP