root/tags/rel-5-0-2/mapserver/mapagg.cpp

/******************************************************************************
 *
 * Project:  MapServer
 * Purpose:  AGG rendering and other AGG related functions.
 * Author:   Steve Lime and the MapServer team.
 *
 ******************************************************************************
 * Copyright (c) 1996-2007 Regents of the University of Minnesota.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in 
 * all copies of this Software or works derived from this Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *****************************************************************************/

#ifdef USE_AGG

#include "mapserver.h"
#include "mapthread.h"


#ifdef _WIN32
#include <fcntl.h>
#include <io.h>
#endif

#include "agg_basics.h"
#include "agg_rendering_buffer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_rasterizer_outline_aa.h"
#include "agg_rasterizer_outline.h"

#include "agg_conv_stroke.h"
#include "agg_conv_dash.h"
#include "agg_conv_curve.h"
#include "agg_conv_contour.h"

#include "agg_scanline_p.h"
#include "agg_path_storage.h"

#include "agg_renderer_base.h"
#include "agg_renderer_scanline.h"
#include "agg_renderer_primitives.h"
#include "agg_renderer_outline_aa.h"
#include "agg_renderer_outline_image.h"

#include "agg_pixfmt_rgb.h"
#include "agg_pixfmt_rgba.h"

#include "agg_arc.h"
#include "agg_ellipse.h"

#include "agg_pattern_filters_rgba.h"

#include "agg_bounding_rect.h"
#include "agg_span_allocator.h"
#include "agg_image_accessors.h"
#include "agg_span_pattern_rgba.h"
#include "agg_span_interpolator_linear.h"
#include "agg_span_image_filter_rgba.h"
#include "agg_span_image_filter_rgb.h"

#include "agg_trans_affine.h"
#include "agg_scanline_boolean_algebra.h"
#include "agg_scanline_storage_aa.h"
#include "math.h"
#include "mapagg.h"

#include <ft2build.h>
#include "agg_font_freetype.h"
#include "agg_font_cache_manager.h"
#define LINESPACE 1.33 //space beween text lines... from GD

#ifdef CPL_MSB
typedef agg::pixfmt_argb32 GDpixfmt; 
typedef agg::pixfmt_alpha_blend_rgba<agg::blender_argb32_plain,mapserv_row_ptr_cache<int>,int> pixelFormat;
typedef agg::pixfmt_alpha_blend_rgba<agg::blender_argb32_pre,mapserv_row_ptr_cache<int>,int> pixelFormat_pre;
#else
typedef agg::pixfmt_bgra32 GDpixfmt;
typedef agg::pixfmt_alpha_blend_rgba<agg::blender_bgra32_plain,mapserv_row_ptr_cache<int>,int> pixelFormat;
typedef agg::pixfmt_alpha_blend_rgba<agg::blender_bgra32_pre,mapserv_row_ptr_cache<int>,int> pixelFormat_pre;

//this how to render to a gdImg while ignoring its funky alpha channel
//however this doesn't work with RGBA imagemode. un-ifdef the endesction in mapagg.h to use
//typedef agg::pixfmt_alpha_blend_rgb_gd<ms_blender_bgr24,mapserv_row_ptr_cache<int> > pixelFormat;
//typedef agg::pixfmt_alpha_blend_rgb_gd<ms_blender_bgr24_pre,mapserv_row_ptr_cache<int> > pixelFormat_pre;

#endif



typedef agg::rgba8 color_type;
typedef agg::font_engine_freetype_int16 font_engine_type;
typedef agg::font_cache_manager<font_engine_type> font_manager_type;
typedef agg::conv_curve<font_manager_type::path_adaptor_type> font_curve_type;

typedef agg::renderer_base<pixelFormat> renderer_base;
typedef agg::renderer_base<pixelFormat_pre> renderer_base_pre;

typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_aa;
typedef agg::renderer_outline_aa<renderer_base> renderer_oaa;
typedef agg::renderer_primitives<renderer_base> renderer_prim;
typedef agg::rasterizer_outline_aa<renderer_oaa> rasterizer_outline_aa;
typedef agg::rasterizer_outline <renderer_prim> rasterizer_outline;
typedef agg::rasterizer_scanline_aa<> rasterizer_scanline;
typedef agg::scanline_p8 scanline;

MS_CVSID("$Id$")

///transform a mapserver shapeobj to an agg path_storage
///@param close set to true for polygons. set to false for lines
///@param ox,oy offset the shape by the given number of pixels
///@returns an agg path_storage
static agg::path_storage shapeToPath(shapeObj *p, bool close, double ox=0, double oy=0) {
    agg::path_storage path;
    for(int i = 0; i < p->numlines; i++) {
        path.move_to(p->line[i].point[0].x, p->line[i].point[0].y);
        for(int j=1; j<p->line[i].numpoints; j++)
            path.line_to(p->line[i].point[j].x, p->line[i].point[j].y);
        if(close)
            path.close_polygon();
    }
    if(ox!=0||oy!=0) {
        path.transform(agg::trans_affine_translation(ox,oy));
    }
    return path;
}

///shortcut function to create a path_storage representing a polygon
///from a shapeobj
static agg::path_storage shapePolygonToPath(shapeObj *p, double ox=0, double oy=0) {
    return shapeToPath(p,true,ox,oy);
}

///shortcut function to create a path_storage representing a polyline
///from a shapeobj
static agg::path_storage shapePolylineToPath(shapeObj *p, double ox=0, double oy=0) {
    return shapeToPath(p,false,ox,oy);
}

///apply line styling functions. applies the line joining and capping
///parameters from the symbolobj to the given stroke
///@param stroke the stroke to which we apply the styling
///@param symbol the symbolobj which may contain the styling info
template<class VertexSource>
static void strokeFromSymbol(VertexSource &stroke, symbolObj *symbol) {
    switch(symbol->linejoin) {
    case MS_CJC_ROUND:
        stroke.line_join(agg::round_join);
        break;
    case MS_CJC_MITER:
        stroke.line_join(agg::miter_join);
        break;
    case MS_CJC_BEVEL:
        stroke.line_join(agg::bevel_join);
        break;
    }
    switch(symbol->linecap) {
    case MS_CJC_BUTT:
        stroke.line_cap(agg::butt_cap);
        break;
    case MS_CJC_ROUND:
        stroke.line_cap(agg::round_cap);
        break;
    case MS_CJC_SQUARE:
        stroke.line_cap(agg::square_cap);
        break;
    }
}
///
///returns a rendering buffer containing the argb pixel values of the gd image.
///the function expects an image with a "gd style" alpha channel, i.e. 
///127...0 actually mapping to 0...255
///NOTE: it is your responsability to free the rendering buffer's memory 
///with a call to delete[](rendering_buffer.buf())
///

static agg::rendering_buffer gdImg2AGGRB_BGRA(gdImagePtr img) {
    int width=img->sx;
    int height=img->sy;
    agg::int8u*           im_data;
    agg::rendering_buffer im_data_rbuf;
    im_data = new agg::int8u[width * height * 4];
    im_data_rbuf.attach(im_data, width,height, width*4);
    for(int row=0;row<height;row++) {
        unsigned int* rowptr=(unsigned int*)im_data_rbuf.row_ptr(row);
        for(int col=0;col<width;col++){
            int gdpix = gdImageGetTrueColorPixel(img,col,row);
            //extract the alpha value from the pixel
            int gdpixalpha = ((gdpix) & 0x7F000000) >> 24;
            int alpha;
            //treat the specific transparent case
            //(we never can set alpha to 0 with newalpha=255-2*oldalpha)
            if(gdpixalpha==127)
                alpha=0;
            else
                alpha=255-(gdpixalpha<<1);
            //reinject the corrected alpha value in the pixel and image
            rowptr[col]=((gdpix)&0x00FFFFFF)|(alpha<<24);            
        }
    }
    return im_data_rbuf;
}

///base rendering class for AGG.
///creates the AGG structures used later for rendering.
///the allocation of these structures does take some time and memory, so
///this object should be cached and not created each time a shape has to be drawn
class AGGMapserverRenderer {
public:
    AGGMapserverRenderer(mapserv_row_ptr_cache<int>  *ptr) :
        pRowCache(ptr),
        thePixelFormat(*pRowCache),
        thePixelFormat_pre(*pRowCache),
        ren_base(thePixelFormat),
        ren_base_pre(thePixelFormat_pre),
        ren_aa(ren_base),
        m_fman(m_feng)
        {
            
        }
    
    ~AGGMapserverRenderer() {
        delete pRowCache;
    }
    ///clear the whole image.
    ///@param color the fully opaque background color to use  
    void clear(colorObj *color) {
        ren_base.clear(msToAGGColor(color));
    }
    
    ///
    ///clear the background of the image. sets the background to fully transparent
    void clear() {
        ren_base.clear(agg::rgba(0,0,0,0));
    }
    
    ///shortcut function to render an ellipse, optinally filled and/or outlined
    ///@param x,y the center of the ellipse
    ///@param w,h the width and height of the ellipse, aligned with the image principal axes
    ///@param color the fill color of the ellipse, or NULL for no fill
    ///@param outlinecolor the color of the outline, or NULL for no outline
    ///@param outlinewidth the width of the optional outline
    void renderEllipse(double x, double y, double w, double h, colorObj *color,
            colorObj *outlinecolor, double outlinewidth=1) {
        agg::path_storage path;
        agg::ellipse ellipse(x,y,w/2.,h/2.0);
        path.concat_path(ellipse);
        renderPathSolid(path,color,outlinecolor,outlinewidth);      
    }
    
    ///render a polyline, optionally dashed
    ///@param p the path_storage containing the vertexes of the polyline
    ///@param c the color of the line
    ///@param width the width of the polyline
    ///@param dashstylelength optional length of the dashing parameters.
    ///     set to 0 for no dashes
    ///@param dashstyle array containing the dashing parameters. it's length must be
    ///     greater or eauql to dashstylelength
    ///@param lc the style of the line caps, defaults to round caps
    ///@param lj the style of the line joins, defaults to round joins
    void renderPolyline(agg::path_storage &p,colorObj *c, 
            double width,int dashstylelength, int *dashstyle,
            enum agg::line_cap_e lc=agg::round_cap,
            enum agg::line_join_e lj=agg::round_join) {
        ras_aa.reset();
        ras_aa.filling_rule(agg::fill_non_zero);
        ren_aa.color(msToAGGColor(c));

        if (dashstylelength <= 0) {
            agg::conv_stroke<agg::path_storage> stroke(p);  
            stroke.width(width);
            stroke.line_cap(lc);
            stroke.line_join(lj);
            ras_aa.add_path(stroke);
        } else {
            agg::conv_dash<agg::path_storage> dash(p);
            agg::conv_stroke<agg::conv_dash<agg::path_storage> > stroke_dash(dash);  
            for (int i=0; i<dashstylelength; i+=2) {
                if (i < dashstylelength-1)
                    dash.add_dash(dashstyle[i], dashstyle[i+1]);
            }
            stroke_dash.width(width);
            stroke_dash.line_cap(lc);
            stroke_dash.line_join(lj);                        
            ras_aa.add_path(stroke_dash);
        }
        agg::render_scanlines(ras_aa, sl, ren_aa);     
    }
    
    ///brush a polyline with a vector symbol. draws the vector symbol in a temporary
    ///image that will be used as a brush for rendering the polyline. this function
    ///doesn't do any actual rendering, it only creates the brush and forwards to the
    ///brush rendering function.
    ///@param shape the polyline to brush
    ///@param symbol the shape of the vector symbol used for brushing,
    ///     can be a stroke or a simple path 
    ///@param tilewidth,tileheight size of the brush to be created
    ///@param color the color the vector symbol should be drawn with
    ///@param backgroundcolor optional background color of the tile, or
    ///     NULL to render the symbol on a transparent background
    template<class VertexSource1, class VertexSource2>
    void renderPolylineVectorSymbol(VertexSource1 &shape, VertexSource2 &symbol,
            int tilewidth, int tileheight, 
            colorObj *color, colorObj *backgroundcolor) {
        ras_aa.reset();
        ras_aa.filling_rule(agg::fill_non_zero);
        typedef agg::wrap_mode_repeat wrap_type;
        typedef agg::image_accessor_wrap<GDpixfmt,wrap_type,wrap_type> img_source_type;
        typedef agg::span_pattern_rgba<img_source_type> span_gen_type;
        agg::int8u*           m_pattern;
        agg::rendering_buffer m_pattern_rbuf;
        m_pattern = new agg::int8u[tilewidth * tileheight * 4];
        m_pattern_rbuf.attach(m_pattern, tilewidth,tileheight, tilewidth*4);

        GDpixfmt pixf(m_pattern_rbuf);
        agg::renderer_base<GDpixfmt> rb(pixf);
        agg::renderer_scanline_aa_solid<agg::renderer_base<GDpixfmt> > rs(rb);

        if(backgroundcolor!=NULL && MS_VALID_COLOR(*backgroundcolor))
            rb.clear(msToAGGColor(backgroundcolor));
        else
            rb.clear(agg::rgba(0,0,0,0));
        rs.color(msToAGGColor(color));
        ras_aa.add_path(symbol);
        agg::render_scanlines(ras_aa, sl, rs);
        renderPathPixmapBGRA(shape,pixf);
        delete[](m_pattern);
    }
    
    ///brush a line.
    ///@param line the line to brush
    ///@param pattern a pixmap to use as a brush. this pattern must be in a 
    ///     premultiplied state, i.e. each color has been divided by its alpha (mapped to 0..1).
    ///     images produced by the AGG renderers are already premultiplied, but images
    ///     read from an another source (i.e the GD pixmaps) should be explicitely
    ///     premultiplied before calling
    void renderPathPixmapBGRA(agg::path_storage &line, GDpixfmt &pattern) {
        agg::pattern_filter_bilinear_rgba8 fltr;
        typedef agg::line_image_pattern<agg::pattern_filter_bilinear_rgba8> pattern_type;
        typedef agg::renderer_outline_image<renderer_base_pre, pattern_type> renderer_img_type;
        typedef agg::rasterizer_outline_aa<renderer_img_type, agg::line_coord_sat> rasterizer_img_type;
        pattern_type patt(fltr);  
        
        patt.create(pattern);
        renderer_img_type ren_img(ren_base_pre, patt);
        rasterizer_img_type ras_img(ren_img);
        ras_img.add_path(line);
    }

    ///render a shape represented by an agg::path_storage
    ///@param path the path containing the geometry to render
    ///@param color fill color or null for no fill
    ///@param outlinecolor outline color or null for no outline
    ///@param outlinewidth width of outline
    ///@param lc capping used for the optional outline, defaults to round caps
    ///@param lj joins used for the optional outline, defaults to round joins
    void renderPathSolid(agg::path_storage &path, colorObj *color,
            colorObj *outlinecolor, double outlinewidth,
            enum agg::line_cap_e lc=agg::round_cap,
            enum agg::line_join_e lj=agg::round_join) {
        ras_aa.reset();
        if(color!=NULL && MS_VALID_COLOR(*color)) {
            //use this to preserve holes in the geometry
            //this is needed when drawing fills
            ras_aa.filling_rule(agg::fill_even_odd);
            ras_aa.add_path ( path );
            ren_aa.color(msToAGGColor(color));
            agg::render_scanlines ( ras_aa, sl, ren_aa );
        }
        if(outlinecolor!=NULL && MS_VALID_COLOR(*outlinecolor) && outlinewidth > 0) {
            ras_aa.reset();
            ras_aa.filling_rule(agg::fill_non_zero); 
            ren_aa.color(msToAGGColor(outlinecolor));
            agg::conv_stroke<agg::path_storage> stroke(path);
            stroke.width(outlinewidth);
            stroke.line_cap(lc);
            stroke.line_join(lj);
            ras_aa.add_path(stroke);
            agg::render_scanlines ( ras_aa, sl, ren_aa );
        }
    }

    ///render a fill pattern clipped by a shape
    ///this has only been tested when pattern is a stroke, and clipper a path.
    ///used for hatches. note that the pattern is not repeated or tiled
    ///@param pattern the pattern to use as the fill
    ///@param clipper the polygon to use as a clipper. only the pixels inside
    ///     this clipper will be affected by the pattern
    ///@param color the color used to render the pattern
    template<class VertexSource1, class VertexSource2>
    void renderPathSolidClipped(VertexSource1 &pattern, VertexSource2 &clipper,
            colorObj *color)
    {
        if(color==NULL || !MS_VALID_COLOR(*color))
            return;
        agg::rasterizer_scanline_aa<> ras1,ras2;
        agg::scanline_storage_aa8 storage;
        agg::scanline_storage_aa8 storage1;
        agg::scanline_storage_aa8 storage2;
        agg::scanline_p8 sl1,sl2;
        ras1.filling_rule(agg::fill_non_zero);
        ras1.add_path(pattern);                    
        agg::render_scanlines(ras1, sl, storage1);
        ras2.filling_rule(agg::fill_even_odd);
        ras2.add_path(clipper);
        agg::render_scanlines(ras2,sl,storage2);
        agg::sbool_combine_shapes_aa(agg::sbool_and, storage1, storage2, sl1, sl2, sl, storage);
        ren_aa.color(msToAGGColor(color));
        agg::render_scanlines ( storage, sl, ren_aa );
    }
    
    ///tile a shape with a vector symbol. this function
    ///doesn't do any actual rendering, it only creates the tile and forwards to the
    ///tiling rendering function.
    ///@param shape the polygon to tile
    ///@param tile the shape of the vector symbol used as a tile,
    ///     can be a stroke or a simple path 
    ///@param tilewidth,tileheight size of the tile to be created
    ///@param color the color the vector symbol should be drawn with
    ///@param backgroundcolor optional background color of the tile, or
    ///     NULL to render the symbol on a transparent background
    ///TODO: add the outlinecolor
    template<class VertexSource1, class VertexSource2>
    void renderPathTiled(VertexSource1 &shape, VertexSource2 &tile,
            int tilewidth, int tileheight, colorObj *color, colorObj *backgroundcolor) 
    {
        ras_aa.reset();
        ras_aa.filling_rule(agg::fill_non_zero);
        agg::int8u*           m_pattern;
        agg::rendering_buffer m_pattern_rbuf;
        m_pattern = new agg::int8u[tilewidth * tileheight * 4];
        m_pattern_rbuf.attach(m_pattern, tilewidth,tileheight, tilewidth*4);

        GDpixfmt pixf(m_pattern_rbuf);
        agg::renderer_base<GDpixfmt> rb(pixf);
        agg::renderer_scanline_aa_solid<agg::renderer_base<GDpixfmt> > rs(rb);
        if(backgroundcolor!=NULL && MS_VALID_COLOR(*backgroundcolor))
            rb.clear(msToAGGColor(backgroundcolor));
        else
            rb.clear(agg::rgba(0,0,0,0));
        rs.color(msToAGGColor(color));
        ras_aa.add_path(tile);
        agg::render_scanlines(ras_aa, sl, rs);
        renderPathTiledPixmapBGRA(shape,pixf);
        delete[](m_pattern);
    }
    ///tile a shape with a truetype character. this function
    ///doesn't do any actual rendering, it only creates the tile and forwards to the
    ///tiling rendering function.
    ///@param shape the polygon to tile
    ///@param font full path of the truetype font file to use
    ///@param glyphUnicode the code of the caracter used 
    ///@param glyphheight size of the character to be rendered
    ///@param gap size in pixels between each rendered character
    ///     (applied vertically and horizontally)
    ///@param color the color the character
    ///@param backgroundcolor optional background color of the tile, or
    ///     NULL to render the symbol on a transparent background
    ///@param outlinecolor optional color of a one pixel width outline drawn around 
    ///     the character, or NULL for no outline       
    template<class VertexSource1>
            void renderPathTruetypeTiled(VertexSource1 &shape, char *font, int glyphUnicode,
                    double glyphheight, double gap, colorObj *color, colorObj *backgroundcolor,
                    colorObj *outlinecolor) 
        {
        if(!m_feng.load_font(font, 0, agg::glyph_ren_outline))
            return;
        m_feng.hinting(true);
        m_feng.height(glyphheight);
        m_feng.resolution(96);
        m_feng.flip_y(true);
        font_curve_type m_curves(m_fman.path_adaptor());
        const agg::glyph_cache* glyph=m_fman.glyph(glyphUnicode);
        if(!glyph) return;
        int gw=glyph->bounds.x2-glyph->bounds.x1,
            gh=glyph->bounds.y2-glyph->bounds.y1;
        int tilewidth=MS_NINT(gw+gap)+1,
            tileheight=MS_NINT(gh+gap)+1;
        
            ras_aa.filling_rule(agg::fill_non_zero);
            agg::int8u* m_pattern;
            agg::rendering_buffer m_pattern_rbuf;
            m_pattern = new agg::int8u[tilewidth * tileheight * 4];
            m_pattern_rbuf.attach(m_pattern, tilewidth,tileheight, tilewidth*4);

            GDpixfmt pixf(m_pattern_rbuf);
            agg::renderer_base<GDpixfmt> rb(pixf);
            agg::renderer_scanline_aa_solid<agg::renderer_base<GDpixfmt> > rs(rb);
            if(backgroundcolor!=NULL && MS_VALID_COLOR(*backgroundcolor))
                rb.clear(msToAGGColor(backgroundcolor));
            else
                rb.clear(agg::rgba(0,0,0,0));
            
            double fy=(tileheight+gh)/2.;
            double fx=(tilewidth-gw)/2.;
            if(outlinecolor!=NULL && MS_VALID_COLOR(*outlinecolor)) {
                ras_aa.reset();
                m_fman.init_embedded_adaptors(glyph,fx,fy);
                for(int i=-1;i<=1;i++)
                    for(int j=-1;j<=1;j++) {
                        if(i||j) { 
                            agg::trans_affine_translation tr(i,j);
                            agg::conv_transform<font_curve_type, agg::trans_affine> trans_c(m_curves, tr);
                            ras_aa.add_path(trans_c);
                        }
                    }
                rs.color(msToAGGColor(outlinecolor));
                agg::render_scanlines(ras_aa, sl, rs);
            }
            if(color!=NULL && MS_VALID_COLOR(*color)) {
                ras_aa.reset();
                m_fman.init_embedded_adaptors(glyph,fx,fy);
                ras_aa.add_path(m_curves);
                rs.color(msToAGGColor(color));
                agg::render_scanlines(ras_aa, sl, rs);
            }
            renderPathTiledPixmapBGRA(shape,pixf);
            delete[](m_pattern);
        }
    
    
    ///tile a path with a pixmap symbol. the pixmap is repeated in each direction
    ///@param path the polygon to fill
    ///@param tile a pixmap to use as a tile. this pixmap must be in a 
    ///     premultiplied state, i.e. each color has been divided by its alpha (mapped to 0..1).
    ///     images produced by the AGG renderers are already premultiplied, but images
    ///     read from an another source (i.e the GD pixmaps) should be explicitely
    ///     premultiplied before calling
    template<class VertexSource1>
    void renderPathTiledPixmapBGRA(VertexSource1 &path ,GDpixfmt &tile) {
        typedef agg::wrap_mode_repeat wrap_type;
        typedef agg::image_accessor_wrap<GDpixfmt,wrap_type,wrap_type> img_source_type;
        typedef agg::span_pattern_rgba<img_source_type> span_gen_type;
        agg::span_allocator<agg::rgba8> sa;
        ras_aa.reset();
        ras_aa.filling_rule(agg::fill_even_odd);
        img_source_type img_src(tile);
        span_gen_type sg(img_src, 0, 0);
        ras_aa.add_path(path);
        agg::render_scanlines_aa(ras_aa, sl, ren_base_pre, sa, sg);
    }

    ///render a single pixmap at a specified location
    ///@param img_pixf the pixmap to render. must be premultiplied
    ///@param x,y where to render the pixmap. this is the point where the
    ///     center of the pixmap will be placed
    ///@param angle,scale angle and scale for rendering the pixmap. angle is in degrees.
    ///     if one of these values is meaningfull (i.e angle!=360 or 0, scale!=1), bilinear
    ///     filtering will be applied. if not the image is copied without subpixel positioning
    ///     (i.e. at the nearest integer position)to avoid the blur caused by the bilinear filtering
    void renderPixmapBGRA(GDpixfmt &img_pixf, double x, double y, double angle, double scale) {
        ras_aa.reset();
        ras_aa.filling_rule(agg::fill_non_zero);
        
        if((angle!=0 && angle!=360) || scale !=1) {
            agg::trans_affine image_mtx;
            image_mtx *= agg::trans_affine_translation(-(double)img_pixf.width()/2.,
                    -(double)img_pixf.height()/2.);
            image_mtx *= agg::trans_affine_rotation(angle * agg::pi / 180.0);
            image_mtx *= agg::trans_affine_scaling(scale);



            image_mtx*= agg::trans_affine_translation(x,y);
            image_mtx.invert();
            typedef agg::span_interpolator_linear<> interpolator_type;
            interpolator_type interpolator(image_mtx);
            agg::span_allocator<agg::rgba8> sa;

            // "hardcoded" bilinear filter
            //------------------------------------------
            typedef agg::span_image_filter_rgba_bilinear_clip<GDpixfmt, interpolator_type> span_gen_type;
            span_gen_type sg(img_pixf, agg::rgba(0,0,0,0), interpolator);
            agg::path_storage pixmap_bbox;
            int ims_2 = MS_NINT(MS_MAX(img_pixf.height(),img_pixf.width())*scale*1.415)/2+1;
            pixmap_bbox.move_to(x-ims_2,y-ims_2);
            pixmap_bbox.line_to(x+ims_2,y-ims_2);
            pixmap_bbox.line_to(x+ims_2,y+ims_2);
            pixmap_bbox.line_to(x-ims_2,y+ims_2);
            pixmap_bbox.close_polygon();      
            ras_aa.add_path(pixmap_bbox);
            agg::render_scanlines_aa(ras_aa, sl, ren_base_pre, sa, sg);
        }
        else {
            //just copy the image at the correct location (we place the pixmap on 
            //the nearest integer pixel to avoid blurring)
            ren_base_pre.blend_from(img_pixf,0,MS_NINT(x-img_pixf.width()/2.),MS_NINT(y-img_pixf.height()/2.));
        }
    }
    
    ///render a freetype string
    ///@param x,y the lower left corner where to start the string, or the center of
    ///     the character if isMarker is true
    ///@param color the font color
    ///@param outlinecolor optional color used for outlining the text
    ///@param size height in pixels of the font
    ///@param font full path of the truetype font to use
    ///@param thechars null terminated string to render
    ///@param angle angle to use. in radians
    ///@param shadowcolor, shdx,shdy color and offset of an optional shadow. defaults
    ///     to being offset one pixel to the lower right.
    ///@param isMarker defines if the text should have its lower left corner start at the
    ///     given x,y (false), or if the text should be centered on x,y (true).
    ///     when set to true, will only center the text if this one is a single character
    int renderGlyphs(double x, double y, colorObj *color, colorObj *outlinecolor,
            double size, char *font, char *thechars, double angle=0,
            colorObj *shadowcolor=NULL, double shdx=1, double shdy=1,
            bool isMarker=false, bool isUTF8Encoded=false) {
        
        ras_aa.filling_rule(agg::fill_non_zero);
        agg::trans_affine mtx;
        mtx *= agg::trans_affine_translation(-x,-y);
        mtx *= agg::trans_affine_rotation(-angle);
        mtx *= agg::trans_affine_translation(x,y);
        
        if(!m_feng.load_font(font, 0, agg::glyph_ren_outline))
        {
            return MS_FAILURE;
        }
        
        m_feng.hinting(true);
        m_feng.height(size);
        //m_feng.width(size);
        m_feng.resolution(96);
        m_feng.flip_y(true);
        font_curve_type m_curves(m_fman.path_adaptor());
        const agg::glyph_cache* glyph;
        
        if(isMarker) {
            /* adjust center wrt the size of the glyph
             * bounds are given in integer coordinates around (0,0)
             * the y axis is flipped
             */
            glyph=m_fman.glyph(thechars[0]);
            x-=glyph->bounds.x1+(glyph->bounds.x2-glyph->bounds.x1)/2.;
            y+=-glyph->bounds.y2+ (glyph->bounds.y2-glyph->bounds.y1)/2.;
        }
        int unicode;
        double fx=x,fy=y;
        const char *utfptr=thechars;
        agg::path_storage glyphs;
        
        //first render all the glyphs to a path
        while(*utfptr) {
            if(*utfptr=='\r') {fx=x;utfptr++;continue;}
            if(*utfptr=='\n') {fx=x;fy+=ceil(size*LINESPACE);utfptr++;continue;}
            if(isUTF8Encoded)
                utfptr+=msUTF8ToUniChar(utfptr, &unicode);
            else {
                unicode=(int)((unsigned char)utfptr[0]);
                utfptr++;
            }
            glyph=m_fman.glyph(unicode);;
            if(glyph)
            {
                m_fman.init_embedded_adaptors(glyph,fx,fy);
                agg::conv_transform<font_curve_type, agg::trans_affine> trans_c(m_curves, mtx);
                glyphs.concat_path(trans_c);
                fx += glyph->advance_x;
                fy += glyph->advance_y;
            }
        }
        
        //use a smoother renderer for the shadow
        if(shadowcolor!=NULL && MS_VALID_COLOR(*shadowcolor)) {
            agg::trans_affine_translation tr(shdx,shdy);
            agg::conv_transform<agg::path_storage, agg::trans_affine> tglyphs(glyphs,tr);
            agg::line_profile_aa prof;
            prof.width(0.5);
            renderer_oaa ren_oaa(ren_base,prof);
            rasterizer_outline_aa rasterizer_smooth(ren_oaa);
            ren_oaa.color(msToAGGColor(shadowcolor));
            rasterizer_smooth.add_path(tglyphs);
        }
        if(outlinecolor!=NULL && MS_VALID_COLOR(*outlinecolor)) {
            ras_aa.reset();
            ras_aa.filling_rule(agg::fill_non_zero);
            //draw the text offset by one pixel in each direction (NW,W,SW,N,S,NE,E,SE)
            for(int i=-1;i<=1;i++) {
                for(int j=-1;j<=1;j++) {
                    if(i||j) {
                        agg::trans_affine_translation tr(i,j);
                        agg::conv_transform<agg::path_storage, agg::trans_affine> tglyphs(glyphs,tr);
                        ras_aa.add_path(tglyphs);
                    }
                }
            }
            ren_aa.color(msToAGGColor(outlinecolor));
            agg::render_scanlines(ras_aa, sl, ren_aa);
        }
    
        if(color!=NULL && MS_VALID_COLOR(*color)) {
            ras_aa.reset();
            ras_aa.filling_rule(agg::fill_non_zero);
            ras_aa.add_path(glyphs);
            ren_aa.color(msToAGGColor(color));
            agg::render_scanlines(ras_aa, sl, ren_aa);
        }
        return MS_SUCCESS;
    }

private:
    mapserv_row_ptr_cache<int>  *pRowCache;
    pixelFormat thePixelFormat;
    pixelFormat_pre thePixelFormat_pre;
    renderer_base ren_base;
    renderer_base_pre ren_base_pre;
    renderer_aa ren_aa;
    scanline sl;
    rasterizer_scanline ras_aa;
    font_engine_type m_feng;
    font_manager_type m_fman;
    agg::rgba msToAGGColor(colorObj *c) {
        return agg::rgba(((double) c->red) / 255.0, 
                ((double) c->green) / 255.0, 
                ((double) c->blue) / 255.0);
    }


};

// ----------------------------------------------------------------------
// Utility function to create a GD image and its associated AGG renderer.
// Returns a pointer to a newly created imageObj structure.
// a pointer to the AGG renderer is stored in the imageObj, used for caching
// ----------------------------------------------------------------------
imageObj *msImageCreateAGG(int width, int height, outputFormatObj *format, char *imagepath, char *imageurl) 
{
    imageObj *pNewImage = NULL;

    if(format->imagemode != MS_IMAGEMODE_RGB && format->imagemode != MS_IMAGEMODE_RGBA) {
      msSetError(MS_AGGERR, "AGG driver only supports RGB or RGBA pixel models.", "msImageCreateAGG()");
      return NULL;
    }

    pNewImage = msImageCreateGD(width, height, format, imagepath, imageurl);
    if(!pNewImage)
      return pNewImage;

    mapserv_row_ptr_cache<int>  *pRowCache = new mapserv_row_ptr_cache<int>(pNewImage->img.gd);
    if(! pRowCache) {
      msSetError(MS_AGGERR, "Error binding GD image to AGG.", "msImageCreateAGG()");
      return NULL;
    }

    AGGMapserverRenderer *ren = new AGGMapserverRenderer(pRowCache);
    pNewImage->imageextra=(void *)ren;
    return pNewImage;
}

///internally used function to get the cached AGG renderer.
AGGMapserverRenderer* getAGGRenderer(imageObj *image) {
    return (AGGMapserverRenderer*)image->imageextra;
}

// ----------------------------------------------------------------------
// Utility function to initialize the color of an image.  The background
// color is passed, but the outputFormatObj is consulted to see if the
// transparency should be set (for RGBA images).
// for the time being we fall back to GD
// ----------------------------------------------------------------------
void msImageInitAGG(imageObj *image, colorObj *background)
{
    /*
    // this is useless for the time being as the pixels are being overwritten by
    // the call to msImageInitGD
    // this block must be uncommented once we remove the call to msImageInitGD
    AGGMapserverRenderer* ren = getAGGRenderer(image);
    if(image->format->imagemode == MS_IMAGEMODE_RGBA) {
        ren->clear();
    } else {
        ren->clear(background);
    }
    */
    msImageInitGD(image, background);
}

// ------------------------------------------------------------------------ 
// Function to create a custom hatch symbol based on an arbitrary angle. 
// ------------------------------------------------------------------------
static agg::path_storage createHatchAGG(int sx, int sy, double angle, double step)<