Ticket #2661: mappdf.c

/******************************************************************************
 * $Id: mappdf.c 7585 2008-05-13 05:19:24Z tbonfort $
 *
 * Project:  MapServer
 * Purpose:  An api for PDF format output using the pdflib or libharu library
 *           http://www.pdflib.com
 *           http://libharu.org
 * Author:   <jwall@webpeak.com> , <jspielberg@webpeak.com>
 * libHaru support: <kyngchaos@kyngchaos.com>
 *
 ******************************************************************************
 * Copyright (c) 1996-2005 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_PDF

#include <assert.h>
#if !defined(_WIN32)
#include <zlib.h>
#endif
#include "mapserver.h"
#if defined USE_HARUPDF
#include <math.h>
#endif

MS_CVSID("$Id: mappdf.c 7585 2008-05-13 05:19:24Z tbonfort $")

/* -------------------------------------------------------------------- */
/*      prototypes.                                                     */
/* -------------------------------------------------------------------- */
/*see mapserver.h*/

#include "mappdf.h"

/* -------------------------------------------------------------------- */
/*      PDF API functions and aliases                                   */
/* -------------------------------------------------------------------- */

/* NOTE: PDFlib PDF object is a pointer, thus needs a * def.  libHaru   */
/*       PDF, page and other objects are structs, and don't need * def. */

/* error handler for libharu */
#if defined USE_HARUPDF
static void error_handler (HPDF_STATUS error_no, HPDF_STATUS detail_no, void *user_data)
{
    /* from haru_font_demo.c:
    printf ("ERROR: error_no=%04X, detail_no=%u\n", (HPDF_UINT)error_no,
                (HPDF_UINT)detail_no);
    longjmp(env, 1);
    */
    msSetError(MS_GDERR, "HPDF error=%04X , detail=%u.", "HPDF_Doc",
                   (HPDF_UINT)error_no, (HPDF_UINT)detail_no);
}
#endif

/* translate page matrix */
static void MAPPDF_Translate(MAPPDF_DRAWOBJ_TYPE pdfpage, float x, float y)
{
#if defined USE_HARUPDF
    HPDF_Page_Concat(pdfpage, 1, 0, 0, 1, x, y);
#elif defined USE_PDFLIB
    PDF_translate(pdfpage, x, y);
#endif
}

/* scale page matrix */
static void MAPPDF_Scale(MAPPDF_DRAWOBJ_TYPE pdfpage, float sx, float sy)
{
#if defined USE_HARUPDF
    HPDF_Page_Concat(pdfpage, sx, 0, 0, sy, 0, 0);
#elif defined USE_PDFLIB
    PDF_scale(pdfpage, sx, sy);
#endif
}

/* rotate page matrix */
static void MAPPDF_Rotate(MAPPDF_DRAWOBJ_TYPE pdfpage, float a)
{
#if defined USE_HARUPDF
    float ca = cosf(MS_DEG_TO_RAD * a);
    float sa = sinf(MS_DEG_TO_RAD * a);
    HPDF_Page_Concat(pdfpage, ca, sa, -sa, ca, 0, 0);
#elif defined USE_PDFLIB
    PDF_rotate(pdfpage, a);
#endif
}

/************************************************************************/
/*                        PDF *initializeDocument                       */
/*                                                                      */
/*              Internal function to create a PDF type                  */
/************************************************************************/
MAPPDF_DOC_TYPE initializeDocument()
{
    /* First we need to make the PDF */
#if defined USE_HARUPDF
    /* Haru always starts in memory */
    HPDF_Doc pdf = HPDF_New(error_handler, NULL);
#elif defined USE_PDFLIB
    PDF *pdf = PDF_new();
    PDF_open_file (pdf,""); /*This creates the file in-memory, not on disk */
#endif
    MAPPDF_FN_SETINFO (pdf, MAPPDF_INFO_CREATOR, "UMN MapServer");
    MAPPDF_FN_SETINFO (pdf, MAPPDF_INFO_AUTHOR, "Implementation for MapServer 3.7 - DM Solutions Group, based on original work by Market Insite Group");
    MAPPDF_FN_SETINFO (pdf, MAPPDF_INFO_TITLE, "DM Solutions Group and Market Insite PDF Map");

    return pdf;
}

/************************************************************************/
/*int msLoadFontSetPDF                                                  */
/*                                                                      */
/* load fonts from file.  for libHaru, we need to setup extra hash      */
/* table to track font name aliases.                                    */
/************************************************************************/
/**** FIXME  loading ALL fontset fonts into the PDF is silly, they may not
             all be used in the map file.  Improved font loading: load
             as needed in the text drawing functions (orig PDFlib
             sortof does this already.  libHaru still needs to track
             alias names.
             Or, maybe PDFlib and Haru clean out unused fonts on save? ****/

#if defined USE_HARUPDF
int msLoadFontSetPDF(fontSetObj *fontset, HPDF_Doc pdf, hashTableObj *hfonts)
#elif defined USE_PDFLIB
int msLoadFontSetPDF(fontSetObj *fontset, PDF *pdf)
#endif
{

#if defined USE_HARUPDF
    HPDF_Page   page;
#endif
    FILE        *stream;
    char        buffer[MS_BUFFER_LENGTH];
    char        alias[64], file1[MS_PATH_LENGTH], file2[MS_PATH_LENGTH];
    char        *path=NULL, *fullPath, szPath[MS_MAXPATHLEN];
    int         i;

    if (fontset == NULL) return(0);
    if (fontset->filename == NULL) return(0);
    
#if defined USE_HARUPDF
    page = HPDF_GetCurrentPage(pdf);
    if (!page)
    {
        msSetError(MS_GDERR, "Unable to get current pdf page.", "msLoadFontSetPDF()");
        return(-1);
    }
    /*initHashTable(hfonts);*/
    hfonts = msCreateHashTable();
#endif

    /**** FIXME  why not use the path paths from the fontset object? - 
                 hasn't the fontset data already been loaded? ****/
    stream =
      fopen(msBuildPath(szPath, fontset->map->mappath, fontset->filename), "r");

    if (!stream)
    {
        msSetError(MS_IOERR, "Error opening fontset %s.", "msLoadFontSetPDF()",
                   fontset->filename);
        return(-1);
    }

    i = 0;
    path = msGetPath(fontset->filename);

    while (fgets(buffer, MS_BUFFER_LENGTH, stream))
    { /* while there's something to load */
#if defined USE_HARUPDF
        /* get discard qualifiers warning otherwise for haru */
        const
#endif
              char *fontParam;

        if(buffer[0] == '#' ||
           buffer[0] == '\n' ||
           buffer[0] == '\r' ||
           buffer[0] == ' ')
            continue; /* skip comments and blank lines */

        fullPath = NULL;
        sscanf(buffer, "%s %s", alias,  file1);

        fullPath = file1;

#if defined(_WIN32) && !defined(__CYGWIN__)
        if(strlen(file1) <= 1 || (file1[0] != '\\' && file1[1] != ':'))
        { /* not a full path */
            sprintf(file2, "%s%s", path, file1);
            fullPath = msBuildPath(szPath, fontset->map->mappath, file2);
        }
#else
       if(file1[0] != '/')
        { /* not full path */
            sprintf(file2, "%s%s", path, file1);
            fullPath = msBuildPath(szPath, fontset->map->mappath, file2);
        }
#endif

        /*ok we have the alias and the full name*/
#if defined USE_HARUPDF
        /* for haru we need to load font AND store returned name in a hashtable */
        /**** FIXME  assume TT only for now, need to check file extension
                     and use appropriate load function ****/
        fontParam = HPDF_LoadTTFontFromFile(pdf, fullPath, 1);
        msInsertHashTable(hfonts, alias, fontParam);
#elif defined USE_PDFLIB
        /* PDFlib allows alias naming of fonts, so it keeps track for us */
        fontParam = (char *)malloc(sizeof(char)*(strlen(fullPath)+strlen(alias)+3));
        sprintf(fontParam, "%s==%s", alias, fullPath);
        PDF_set_parameter(pdf, "FontOutline", fontParam);
        free(fontParam);
#endif
        i++;
    }

    fclose(stream); /* close the file */

    if( path )
        free(path);

    return(0);
}

/************************************************************************/
/*                        imageObj *msImageCreatePDF                    */
/*                                                                      */
/*      Utility function to create an image object of PDF type          */
/************************************************************************/
imageObj *msImageCreatePDF(int width, int height, outputFormatObj *format,
                           char *imagepath, char *imageurl, mapObj *map)
{
    imageObj         *oImage = NULL;
    MAPPDF_DOC_TYPE  pdf = NULL;
#if defined USE_HARUPDF
    HPDF_Page        page = NULL;
#endif
    char             *driver = strdup("GD/GIF");

    assert(strcasecmp(format->driver,"PDF") == 0);

    oImage = (imageObj *)calloc(1,sizeof(imageObj));

    oImage->format = format;
    format->refcount++;

    oImage->width = width;
    oImage->height = height;
    oImage->imagepath = NULL;
    oImage->imageurl = NULL;

    if (imagepath)
    {
        oImage->imagepath = strdup(imagepath);
    }
    if (imageurl)
    {
        oImage->imageurl = strdup(imageurl);
    }

    oImage->img.pdf = (PDFObj *)malloc(sizeof(PDFObj));
    oImage->img.pdf->pdf = NULL;
    oImage->img.pdf->pdf = initializeDocument();
    oImage->img.pdf->map = map;
    if(!oImage->img.pdf->pdf)
    {
        msSetError(MS_GDERR, "Unable to initialize pdfPage.", "msDrawMap()");
        return(NULL);
    }

    pdf = oImage->img.pdf->pdf;
    /*  load fonts and set the pdf ready to be drawn into*/
#if defined USE_HARUPDF
    /* oImage->img.pdf->hfonts = NULL; */
    msLoadFontSetPDF(&(map->fontset), pdf, &(oImage->img.pdf->hfonts));
    page = HPDF_AddPage(pdf);
    if (!page)
    {
        msSetError(MS_GDERR, "Unable to add new pdf page.", "msDrawMap()");
        return(NULL);
    }
    HPDF_Page_SetWidth(page, (float)width);
    HPDF_Page_SetHeight(page, (float)height);
#elif defined USE_PDFLIB
    msLoadFontSetPDF((&(map->fontset)), pdf);
    PDF_begin_page(pdf, (float)width, (float)height);
#endif

    /* pdf has it's origin in the bottom left so we need to flip the coordinate */
    /* system to fit with the rest of mapserver. */
    MAPPDF_Translate(MAPPDF_DRAWOBJ, 0, (float)map->height);
    MAPPDF_Scale(MAPPDF_DRAWOBJ, 1, -1);

    /*render text with both a fill and a stroke*/
#if defined USE_HARUPDF
    HPDF_Page_SetTextRenderingMode(page, HPDF_FILL_THEN_STROKE);
#elif defined USE_PDFLIB
    PDF_set_value(pdf, "textrendering", 2);
#endif

/* -------------------------------------------------------------------- */
/*      if the output raster, we create a GD image that                 */
/*      will be used to contain the rendering of all the layers.        */
/* -------------------------------------------------------------------- */
    if (strcasecmp(msGetOutputFormatOption(oImage->format,"OUTPUT_TYPE",""), 
                   "RASTER") != 0)
    {
        oImage->img.pdf->imagetmp = NULL;
    }
    else
    {
#ifdef USE_GD_GIF
        driver = strdup("GD/GIF");
#else

#ifdef USE_GD_PNG
        driver = strdup("GD/PNG");
#else

#ifdef USE_GD_JPEG
        driver = strdup("GD/JPEG");
#else

#ifdef USE_GD_WBMP
        driver = strdup("GD/WBMP");
#endif

#endif
#endif
#endif

        oImage->img.pdf->imagetmp = (imageObj *) 
          msImageCreateGD(map->width, map->height,
                          msCreateDefaultOutputFormat(map, driver),
                          map->web.imagepath, map->web.imageurl);
    }
    return oImage;
}

/************************************************************************/
/* void drawPolylinePDF                                                 */
/*                                                                      */
/* internal function to do line drawing in the pdf                      */
/************************************************************************/
void drawPolylinePDF(MAPPDF_DOC_TYPE pdf, shapeObj *p, colorObj  *c, double width)
{
    int        i, j;
#if defined USE_HARUPDF
    HPDF_Page  page = NULL;

    page = HPDF_GetCurrentPage(pdf);
    if (!page)
    {
        msSetError(MS_GDERR, "Unable to get current pdf page.", "msDrawMap()");
        return;
    }
#endif

    if (width)
    {
        MAPPDF_FN_SETLINEJOIN(MAPPDF_DRAWOBJ, MAPPDF_LINEJOIN_ROUND);
        MAPPDF_FN_SETLINEWIDTH(MAPPDF_DRAWOBJ, (float)width);
    }

    if (c)
    {
        /* old version set both fill & stroke color, but we only need stroke */
        MAPPDF_FN_SETRGBSTROKECOLOR(MAPPDF_DRAWOBJ, (float)c->red/255,
                                                    (float)c->green/255,
                                                    (float)c->blue/255);
    }

    for (i = 0; i < p->numlines; i++)
    {
        if (p->line[i].numpoints)
        {
            MAPPDF_FN_MOVETO(MAPPDF_DRAWOBJ, (float)p->line[i].point[0].x,
                                             (float)p->line[i].point[0].y);
        }
        for(j=1; j<p->line[i].numpoints; j++)
        {
            MAPPDF_FN_LINETO(MAPPDF_DRAWOBJ, (float)p->line[i].point[j].x,
                                             (float)p->line[i].point[j].y);
        }
    }
    MAPPDF_FN_STROKE(MAPPDF_DRAWOBJ);
/*  MAPPDF_FN_SETLINEJOIN(MAPPDF_DRAWOBJ, MAPPDF_LINEJOIN_MITER); */
    MAPPDF_FN_SETLINEWIDTH(MAPPDF_DRAWOBJ, 1);

}

/**** FIXME  why pdflib >= 6?  I see dashed lines in v5.  bugs? ****/
#if defined USE_HARUPDF || (defined USE_PDFLIB && PDFLIB_MAJORVERSION >= 6)
 /************************************************************************/
 /* void drawDashedPolylinePDF                                           */
 /*                                                                      */
 /* internal function to do line drawing in the pdf, using dashed        */
 /* patterns.  Note that haru currently has a max pattern length of 8    */
 /* while MS has a max of 10.                                            */
 /************************************************************************/
 void drawDashedPolylinePDF(MAPPDF_DOC_TYPE pdf, shapeObj *p, symbolObj  *s,
                            colorObj *c, double width)
 {
    int          i, j;
#if defined USE_HARUPDF
    HPDF_Page    page = NULL;
    HPDF_UINT16  optlist[8];
#elif defined USE_PDFLIB
    int          optlistlength = 14;
    char         *optlist = NULL;
#endif

#if defined USE_HARUPDF
    page = HPDF_GetCurrentPage(pdf);
    if (!page)
    {
        msSetError(MS_GDERR, "Unable to get current pdf page.", "msDrawMap()");
        return;
    }

    if (s->patternlength > 8)
    {
        msSetError(MS_SYMERR, "Max PDF pattern length is 8.", "drawDashedPolylinePDF()");
        return;
    }
#endif
    
    if (s->patternlength > 0)
    {
        for (i = 0; i < s->patternlength; i++)
        {
            if (s->pattern[i] > 0)
#if defined USE_HARUPDF
                optlist[i] = (HPDF_UINT16)s->pattern[i];
#elif defined USE_PDFLIB
                optlistlength += (int)(log10(s->pattern[i])) + 2;
#endif
            else
            {
                msSetError(MS_SYMERR, "Symbol patterns must be positive.", "drawDashedPolylinePDF()");
                return;
            }
        }
#if defined USE_HARUPDF
        HPDF_Page_SetDash(page, optlist, s->patternlength, 0);
#elif defined USE_PDFLIB
        optlist = (char*)malloc(optlistlength*sizeof(char));
        sprintf(optlist, "dasharray={");
        for (i = 0; i < s->patternlength; i++)
            sprintf(optlist, "%s %d", optlist, s->pattern[i]);
        sprintf(optlist, "%s }", optlist);
        PDF_setdashpattern(pdf, optlist);
#endif
    }

    if (width)
    {
        MAPPDF_FN_SETLINEJOIN(MAPPDF_DRAWOBJ, MAPPDF_LINEJOIN_ROUND);
        MAPPDF_FN_SETLINEWIDTH(MAPPDF_DRAWOBJ, (float)width);
    }

    if (c)
    {
        MAPPDF_FN_SETRGBSTROKECOLOR(MAPPDF_DRAWOBJ, (float)c->red/255,
                                                    (float)c->green/255,
                                                    (float)c->blue/255);
    }

    for (i = 0; i < p->numlines; i++)
    {
        if (p->line[i].numpoints)
        {
            MAPPDF_FN_MOVETO(MAPPDF_DRAWOBJ, (float)p->line[i].point[0].x,
                                             (float)p->line[i].point[0].y);
        }
        for(j = 1; j<p->line[i].numpoints; j++)
        {
            MAPPDF_FN_LINETO(MAPPDF_DRAWOBJ, (float)p->line[i].point[j].x,
                                             (float)p->line[i].point[j].y);
        }
    }
     
    MAPPDF_FN_STROKE(MAPPDF_DRAWOBJ);
#if defined USE_HARUPDF
    HPDF_Page_SetDash(page, NULL, 0, 0);
#elif defined USE_PDFLIB
    PDF_setdashpattern(pdf, "");
    free(optlist); 
#endif
    MAPPDF_FN_SETLINEWIDTH(MAPPDF_DRAWOBJ, 1);
}
#endif

/************************************************************************/
/*  void msDrawLineSymbolPDF                                            */
/*                                                                      */
/*  Draw a line symbol of the specified size and color                  */
/************************************************************************/
void msDrawLineSymbolPDF(symbolSetObj *symbolset, imageObj *image, shapeObj *p,
                         styleObj *style, double scalefactor)
{
    int              size;
    MAPPDF_DOC_TYPE  pdf;

    if (style->size == -1)
    {
        size = msSymbolGetDefaultSize(symbolset->symbol[style->symbol]);
        size = MS_NINT(size*scalefactor);
    }
    else
        size = MS_NINT(style->size*scalefactor);
    pdf = image->img.pdf->pdf;

    if (p->numlines <= 0)
        return;

  /* no such symbol, 0 is OK */
    if (style->symbol > symbolset->numsymbols || style->symbol < 0)
        return;

    if (!(MS_VALID_COLOR(style->color))) /* invalid color */
        return;

    if (size < 1) /* size too small */
        return;

#if defined USE_HARUPDF || (defined USE_PDFLIB && PDFLIB_MAJORVERSION >= 6)
    if (symbolset && symbolset->symbol[style->symbol]->patternlength)
       drawDashedPolylinePDF(pdf, p, symbolset->symbol[style->symbol], 
                             &(style->color), size);
    else
#endif
       drawPolylinePDF(pdf, p, &(style->color),  size);

    return;
}

/************************************************************************/
/*  void msFilledPolygonPDF                                             */
/*                                                                      */
/*  creates a filled polygon in the pdf from a shape                    */
/*  Note: not part of external api, despite name                        */
/************************************************************************/
void msFilledPolygonPDF(MAPPDF_DOC_TYPE pdf, shapeObj *p, colorObj  *c)
{
    int        i, j;
#if defined USE_HARUPDF
    HPDF_Page  page = NULL;

    page = HPDF_GetCurrentPage(pdf);
    if (!page)
    {
        msSetError(MS_GDERR, "Unable to get current pdf page.", "msDrawMap()");
        return;
    }
#endif

    if (c)
    {
        MAPPDF_FN_SETRGBSTROKECOLOR(MAPPDF_DRAWOBJ, (float)c->red/255,
                                                    (float)c->green/255,
                                                    (float)c->blue/255);
        MAPPDF_FN_SETRGBFILLCOLOR(MAPPDF_DRAWOBJ, (float)c->red/255,
                                                  (float)c->green/255,
                                                  (float)c->blue/255);
    }
    
    for (i = 0; i < p->numlines; i++)
    {
        if (p->line[i].numpoints)
        {
            MAPPDF_FN_MOVETO(MAPPDF_DRAWOBJ, (float)p->line[i].point[0].x,
                                             (float)p->line[i].point[0].y);
        }
        for(j=1; j<p->line[i].numpoints; j++){
            MAPPDF_FN_LINETO(MAPPDF_DRAWOBJ, (float)p->line[i].point[j].x,
                                             (float)p->line[i].point[j].y);
        }
    }
    MAPPDF_FN_CLOSEFILLSTROKE(MAPPDF_DRAWOBJ);

}

/************************************************************************/
/*  void billboardPDF                                                   */
/*                                                                      */
/*  creates a filled polygon in the pdf as a background                 */
/************************************************************************/
void billboardPDF(MAPPDF_DOC_TYPE pdf, shapeObj *shape, labelObj *label)
{
    int       i;
    shapeObj  temp;

    msInitShape(&temp);
    msAddLine(&temp, &shape->line[0]);

    if (label->backgroundshadowcolor.pen >= 0)
    {
        for (i=0; i<temp.line[0].numpoints; i++)
        {
            temp.line[0].point[i].x += label->backgroundshadowsizex;
            temp.line[0].point[i].y += label->backgroundshadowsizey;
        }
        msFilledPolygonPDF(pdf, &temp, &label->backgroundshadowcolor);
        for (i=0; i<temp.line[0].numpoints; i++)
        {
            temp.line[0].point[i].x -= label->backgroundshadowsizex;
            temp.line[0].point[i].y -= label->backgroundshadowsizey;
        }
    }

    msFilledPolygonPDF(pdf, &temp, &label->backgroundcolor);

    msFreeShape(&temp);
}

/************************************************************************/
/*  void msDrawLabelPDF                                                 */
/*                                                                      */
/*  draws a single label at the specified position                      */
/************************************************************************/
int msDrawLabelPDF(imageObj *image, pointObj labelPnt, char *string,
                   labelObj *label, fontSetObj *fontset, double scalefactor)
{
    if (!string)
        return(0); /* not an error, just don't want to do anything */

    if (strlen(string) == 0)
        return(0); /* not an error, just don't want to do anything */

    if (label->position != MS_XY)
    {
        pointObj p;
        rectObj r;

        if (msGetLabelSize(image,string, label, &r, fontset, scalefactor, MS_FALSE) == -1)
            return(-1);
        p = get_metrics(&labelPnt, label->position, r,
                                   label->offsetx, label->offsety,
                                   label->angle, 0, NULL);
        msDrawTextPDF(image, p, string,
                 label, fontset, scalefactor);
    }
    else
    {
        labelPnt.x += label->offsetx;
        labelPnt.y += label->offsety;
        msDrawTextPDF(image,labelPnt, string,
                 label, fontset, scalefactor);
    }

    return(0);

}

/************************************************************************/
/*  int msDrawLabelCachePDF                                             */
/*                                                                      */
/*  draws a set of labels                                               */
/************************************************************************/
int msDrawLabelCachePDF(imageObj *image, mapObj *map)
{
    pointObj             p;
    int                  i, j, l, priority;
    rectObj              r;
    labelCacheMemberObj  *cachePtr=NULL;
    layerObj             *layerPtr=NULL;
    labelObj             *labelPtr=NULL;

    int      draw_marker;
    int      marker_width, marker_height;
    int      marker_offset_x, marker_offset_y;
    rectObj  marker_rect;
    
    imageObj *imagetmp = NULL;

/* -------------------------------------------------------------------- */
/*      if not PDF, return.                                             */
/* -------------------------------------------------------------------- */
    if (image == NULL || map == NULL || !MS_DRIVER_PDF(image->format))
        return -1;
/* -------------------------------------------------------------------- */
/*      if the output raster, we crate a GD image that                  */
/*      will be used to conating the rendering of all the layers.       */
/* -------------------------------------------------------------------- */
    if (strcasecmp(msGetOutputFormatOption(image->format,"OUTPUT_TYPE",""), 
                   "RASTER") == 0)
    {
        int orig_renderer;
        imagetmp = (imageObj *)image->img.pdf->imagetmp;
        msImageInitGD( imagetmp, &map->imagecolor);
        orig_renderer=image->format->renderer;
        image->format->renderer = MS_RENDER_WITH_GD;
        msDrawLabelCache(imagetmp, map);
        image->format->renderer = orig_renderer;
        return 0;
    }

    for (priority=MS_MAX_LABEL_PRIORITY-1; priority>=0; priority--)
    {
        labelCacheSlotObj *cacheslot;
        cacheslot = &(map->labelcache.slots[priority]);

        for (l=cacheslot->numlabels-1; l>=0; l--)
        {
            /* point to right spot in cache */
            cachePtr = &(cacheslot->labels[l]);

            /* set a couple of other pointers, avoids nasty references */
            layerPtr = (GET_LAYER(map, cachePtr->layerindex));
            /* classPtr = &(cachePtr->class); */
            labelPtr = &(cachePtr->label);

            if (!cachePtr->text)
                continue; /* not an error, just don't want to do anything */

            if (strlen(cachePtr->text) == 0)
                continue; /* not an error, just don't want to do anything */

            if (msGetLabelSize(image,cachePtr->text, labelPtr, &r, &(map->fontset), layerPtr->scalefactor, MS_TRUE) == -1)
                return(-1);

            if (labelPtr->autominfeaturesize && ((r.maxx-r.minx) > cachePtr->featuresize))
                continue; /* label too large relative to the feature */

            draw_marker = marker_offset_x = marker_offset_y = 0; /* assume no marker */
            if (layerPtr->type == MS_LAYER_ANNOTATION || layerPtr->type == MS_LAYER_POINT)
            { /* there *is* a marker */

                    /* TO DO: at the moment only checks the bottom style,
                       perhaps should check all of them */
                if (cachePtr->numstyles==0)
                    marker_width = marker_height = 1;
                else if (msGetMarkerSize(&map->symbolset, &(cachePtr->styles[0]), &marker_width, &marker_height, layerPtr->scalefactor) != MS_SUCCESS)
                        return(-1);

                marker_offset_x = MS_NINT(marker_width/2.0);
                marker_offset_y = MS_NINT(marker_height/2.0);

                marker_rect.minx = MS_NINT(cachePtr->point.x - .5 * marker_width);
                marker_rect.miny = MS_NINT(cachePtr->point.y - .5 * marker_height);
                marker_rect.maxx = marker_rect.minx + (marker_width-1);
                marker_rect.maxy = marker_rect.miny + (marker_height-1);

                /* actually draw the marker */
                if (layerPtr->type == MS_LAYER_ANNOTATION) draw_marker = 1;
            }

            if (labelPtr->position == MS_AUTO)
            {
                if (layerPtr->type == MS_LAYER_LINE)
                {
                    int position = MS_UC;
            
                    /* Two angles or two positions, depending on angle. Steep angles */
                    /* will use the angle approach, otherwise we'll rotate between*/
                    /* UC and LC. */
                    for (j=0; j<2; j++)
                    {
                        msFreeShape(cachePtr->poly);
                        /* assume label *can* be drawn */
                        cachePtr->status = MS_TRUE;

                        p = get_metrics(&(cachePtr->point), position, r,
                                        (marker_offset_x + labelPtr->offsetx),
                                        (marker_offset_y + labelPtr->offsety),
                                        labelPtr->angle, labelPtr->buffer, cachePtr->poly);

                        /*save marker bounding polygon*/
                        if (draw_marker)
                            msRectToPolygon(marker_rect, cachePtr->poly);

                        /* Compare against image bounds, rendered labels and markers
                           (sets cachePtr->status) */
                        msTestLabelCacheCollisions(&(map->labelcache), labelPtr, 
                                                   map->width, map->height, 
                                                   labelPtr->buffer, cachePtr, priority, l);

                        /*found a suitable place for this label*/
                        if (cachePtr->status)
                            break;

                    }  /*next angle*/

                }
                else
                {
                    /* loop through the outer label positions */
                    for (j=0; j<=7; j++)
                    {
                        msFreeShape(cachePtr->poly);
                        /* assume label *can* be drawn */
                        cachePtr->status = MS_TRUE;

                        p = get_metrics(&(cachePtr->point), j, r,
                                        (marker_offset_x + labelPtr->offsetx),
                                        (marker_offset_y + labelPtr->offsety),
                                        labelPtr->angle, labelPtr->buffer, cachePtr->poly);

                        /* save marker bounding polygon*/
                        if (draw_marker)
                            msRectToPolygon(marker_rect, cachePtr->poly);

                        /* Compare against image bounds, rendered labels and markers
                           (sets cachePtr->status) */
                        msTestLabelCacheCollisions(&(map->labelcache), labelPtr, 
                                                   map->width, map->height, 
                                                   labelPtr->buffer, cachePtr, priority, l);

                        /* found a suitable place for this label*/
                        if (cachePtr->status)
                            break;
                    } /*next position*/
                }

                /* draw in spite of collisions based on last position,
                   need a *best* position */
                if (labelPtr->force) cachePtr->status = MS_TRUE;
            }
            else
            {
                /* assume label *can* be drawn */
                cachePtr->status = MS_TRUE;

                /*don't need the marker_offset*/
                if (labelPtr->position == MS_CC)
                {
                    p = get_metrics(&(cachePtr->point), labelPtr->position, r,
                                    labelPtr->offsetx, labelPtr->offsety,
                                    labelPtr->angle,  labelPtr->buffer, cachePtr->poly);
                }