python-mapnik 2.2.0+ds1-7+b2 / usr / lib / python2.7 / dist-packages / mapnik / printing.py

# -*- coding: utf-8 -*-

"""Mapnik classes to assist in creating printable maps

basic usage is along the lines of

import mapnik

page = mapnik.printing.PDFPrinter()
m = mapnik.Map(100,100)
mapnik.load_map(m, "my_xml_map_description", True)
m.zoom_all()
page.render_map(m,"my_output_file.pdf")

see the documentation of mapnik.printing.PDFPrinter() for options

"""
from __future__ import absolute_import

from . import render, Map, Box2d, MemoryDatasource, Layer, Feature, Projection, ProjTransform, Coord, Style, Rule, Geometry2d
import math
import os
import tempfile

try:
    import cairo
    HAS_PYCAIRO_MODULE = True
except ImportError:
    HAS_PYCAIRO_MODULE = False

try:
    import pangocairo
    import pango
    HAS_PANGOCAIRO_MODULE = True
except ImportError:
    HAS_PANGOCAIRO_MODULE = False

try:
    import pyPdf
    HAS_PYPDF = True
except ImportError:
    HAS_PYPDF = False

class centering:
    """Style of centering to use with the map, the default is constrained

    none: map will be placed flush with the margin/box in the top left corner
    constrained: map will be centered on the most constrained axis (for a portrait page
                 and a square map this will be horizontally)
    unconstrained: map will be centered on the unconstrained axis
    vertical:
    horizontal:
    both:
    """
    none=0
    constrained=1
    unconstrained=2
    vertical=3
    horizontal=4
    both=5

"""Some predefined page sizes custom sizes can also be passed
a tuple of the page width and height in meters"""
pagesizes = {
    "a0": (0.841000,1.189000),
    "a0l": (1.189000,0.841000),
    "b0": (1.000000,1.414000),
    "b0l": (1.414000,1.000000),
    "c0": (0.917000,1.297000),
    "c0l": (1.297000,0.917000),
    "a1": (0.594000,0.841000),
    "a1l": (0.841000,0.594000),
    "b1": (0.707000,1.000000),
    "b1l": (1.000000,0.707000),
    "c1": (0.648000,0.917000),
    "c1l": (0.917000,0.648000),
    "a2": (0.420000,0.594000),
    "a2l": (0.594000,0.420000),
    "b2": (0.500000,0.707000),
    "b2l": (0.707000,0.500000),
    "c2": (0.458000,0.648000),
    "c2l": (0.648000,0.458000),
    "a3": (0.297000,0.420000),
    "a3l": (0.420000,0.297000),
    "b3": (0.353000,0.500000),
    "b3l": (0.500000,0.353000),
    "c3": (0.324000,0.458000),
    "c3l": (0.458000,0.324000),
    "a4": (0.210000,0.297000),
    "a4l": (0.297000,0.210000),
    "b4": (0.250000,0.353000),
    "b4l": (0.353000,0.250000),
    "c4": (0.229000,0.324000),
    "c4l": (0.324000,0.229000),
    "a5": (0.148000,0.210000),
    "a5l": (0.210000,0.148000),
    "b5": (0.176000,0.250000),
    "b5l": (0.250000,0.176000),
    "c5": (0.162000,0.229000),
    "c5l": (0.229000,0.162000),
    "a6": (0.105000,0.148000),
    "a6l": (0.148000,0.105000),
    "b6": (0.125000,0.176000),
    "b6l": (0.176000,0.125000),
    "c6": (0.114000,0.162000),
    "c6l": (0.162000,0.114000),
    "a7": (0.074000,0.105000),
    "a7l": (0.105000,0.074000),
    "b7": (0.088000,0.125000),
    "b7l": (0.125000,0.088000),
    "c7": (0.081000,0.114000),
    "c7l": (0.114000,0.081000),
    "a8": (0.052000,0.074000),
    "a8l": (0.074000,0.052000),
    "b8": (0.062000,0.088000),
    "b8l": (0.088000,0.062000),
    "c8": (0.057000,0.081000),
    "c8l": (0.081000,0.057000),
    "a9": (0.037000,0.052000),
    "a9l": (0.052000,0.037000),
    "b9": (0.044000,0.062000),
    "b9l": (0.062000,0.044000),
    "c9": (0.040000,0.057000),
    "c9l": (0.057000,0.040000),
    "a10": (0.026000,0.037000),
    "a10l": (0.037000,0.026000),
    "b10": (0.031000,0.044000),
    "b10l": (0.044000,0.031000),
    "c10": (0.028000,0.040000),
    "c10l": (0.040000,0.028000),
    "letter": (0.216,0.279),
    "letterl": (0.279,0.216),
    "legal": (0.216,0.356),
    "legall": (0.356,0.216),
}
"""size of a pt in meters"""
pt_size=0.0254/72.0

def m2pt(x):
    """convert distance from meters to points"""
    return x/pt_size

def pt2m(x):
    """convert distance from points to meters"""
    return x*pt_size

def m2in(x):
    """convert distance from meters to inches"""
    return x/0.0254

def m2px(x,resolution):
    """convert distance from meters to pixels at the given resolution in DPI/PPI"""
    return m2in(x)*resolution

class resolutions:
    """some predefined resolutions in DPI"""
    dpi72=72
    dpi150=150
    dpi300=300
    dpi600=600

def any_scale(scale):
    """Scale helper function that allows any scale"""
    return scale

def sequence_scale(scale,scale_sequence):
    """Default scale helper, this rounds scale to a 'sensible' value"""
    factor = math.floor(math.log10(scale))
    norm = scale/(10**factor)

    for s in scale_sequence:
        if norm <= s:
            return s*10**factor
    return scale_sequence[0]*10**(factor+1)

def default_scale(scale):
    """Default scale helper, this rounds scale to a 'sensible' value"""
    return sequence_scale(scale, (1,1.25,1.5,1.75,2,2.5,3,4,5,6,7.5,8,9,10))

def deg_min_sec_scale(scale):
    for x in (1.0/3600,
              2.0/3600,
              5.0/3600,
              10.0/3600,
              30.0/3600,
              1.0/60,
              2.0/60,
              5.0/60,
              10.0/60,
              30.0/60,
              1,
              2,
              5,
              10,
              30,
              60
              ):
        if scale < x:
            return x
    else:
        return x

def format_deg_min_sec(value):
    deg = math.floor(value)
    min = math.floor((value-deg)/(1.0/60))
    sec = int((value - deg*1.0/60)/1.0/3600)
    return "%d°%d'%d\"" % (deg,min,sec)

def round_grid_generator(first,last,step):
        val = (math.floor(first / step) + 1) * step
        yield val
        while val < last:
            val += step
            yield val


def convert_pdf_pages_to_layers(filename,output_name=None,layer_names=(),reverse_all_but_last=True):
    """
    opens the given multipage PDF and converts each page to be a layer in a single page PDF
    layer_names should be a sequence of the user visible names of the layers, if not given
    or if shorter than num pages generic names will be given to the unnamed layers

    if output_name is not provided a temporary file will be used for the conversion which
    will then be copied back over the source file.

    requires pyPdf >= 1.13 to be available"""


    if not HAS_PYPDF:
        raise Exception("pyPdf Not available")

    infile = file(filename, 'rb')
    if output_name:
        outfile = file(output_name, 'wb')
    else:
        (outfd,outfilename) = tempfile.mkstemp(dir=os.path.dirname(filename))
        outfile = os.fdopen(outfd,'wb')

    i = pyPdf.PdfFileReader(infile)
    o = pyPdf.PdfFileWriter()

    template_page_size = i.pages[0].mediaBox
    op = o.addBlankPage(width=template_page_size.getWidth(),height=template_page_size.getHeight())

    contentkey = pyPdf.generic.NameObject('/Contents')
    resourcekey = pyPdf.generic.NameObject('/Resources')
    propertieskey = pyPdf.generic.NameObject('/Properties')
    op[contentkey] = pyPdf.generic.ArrayObject()
    op[resourcekey] = pyPdf.generic.DictionaryObject()
    properties = pyPdf.generic.DictionaryObject()
    ocgs = pyPdf.generic.ArrayObject()

    for (i, p) in enumerate(i.pages):
        # first start an OCG for the layer
        ocgname = pyPdf.generic.NameObject('/oc%d' % i)
        ocgstart = pyPdf.generic.DecodedStreamObject()
        ocgstart._data = "/OC %s BDC\n" % ocgname
        ocgend = pyPdf.generic.DecodedStreamObject()
        ocgend._data = "EMC\n"
        if isinstance(p['/Contents'],pyPdf.generic.ArrayObject):
            p[pyPdf.generic.NameObject('/Contents')].insert(0,ocgstart)
            p[pyPdf.generic.NameObject('/Contents')].append(ocgend)
        else:
            p[pyPdf.generic.NameObject('/Contents')] = pyPdf.generic.ArrayObject((ocgstart,p['/Contents'],ocgend))

        op.mergePage(p)

        ocg = pyPdf.generic.DictionaryObject()
        ocg[pyPdf.generic.NameObject('/Type')] = pyPdf.generic.NameObject('/OCG')
        if len(layer_names) > i:
            ocg[pyPdf.generic.NameObject('/Name')] = pyPdf.generic.TextStringObject(layer_names[i])
        else:
            ocg[pyPdf.generic.NameObject('/Name')] = pyPdf.generic.TextStringObject('Layer %d' % (i+1))
        indirect_ocg = o._addObject(ocg)
        properties[ocgname] = indirect_ocg
        ocgs.append(indirect_ocg)

    op[resourcekey][propertieskey] = o._addObject(properties)

    ocproperties = pyPdf.generic.DictionaryObject()
    ocproperties[pyPdf.generic.NameObject('/OCGs')] = ocgs
    defaultview = pyPdf.generic.DictionaryObject()
    defaultview[pyPdf.generic.NameObject('/Name')] = pyPdf.generic.TextStringObject('Default')
    defaultview[pyPdf.generic.NameObject('/BaseState ')] = pyPdf.generic.NameObject('/ON ')
    defaultview[pyPdf.generic.NameObject('/ON')] = ocgs
    if reverse_all_but_last:
        defaultview[pyPdf.generic.NameObject('/Order')] = pyPdf.generic.ArrayObject(reversed(ocgs[:-1]))
        defaultview[pyPdf.generic.NameObject('/Order')].append(ocgs[-1])
    else:
        defaultview[pyPdf.generic.NameObject('/Order')] = pyPdf.generic.ArrayObject(reversed(ocgs))
    defaultview[pyPdf.generic.NameObject('/OFF')] = pyPdf.generic.ArrayObject()

    ocproperties[pyPdf.generic.NameObject('/D')] = o._addObject(defaultview)

    o._root.getObject()[pyPdf.generic.NameObject('/OCProperties')] = o._addObject(ocproperties)

    o.write(outfile)

    outfile.close()
    infile.close()

    if not output_name:
        os.rename(outfilename, filename)

class PDFPrinter:
    """Main class for creating PDF print outs, basically contruct an instance
    with appropriate options and then call render_map with your mapnik map
    """
    def __init__(self, 
                 pagesize=pagesizes["a4"], 
                 margin=0.005, 
                 box=None,
                 percent_box=None,
                 scale=default_scale, 
                 resolution=resolutions.dpi72,
                 preserve_aspect=True,
                 centering=centering.constrained,
                 is_latlon=False,
                 use_ocg_layers=False):
        """Creates a cairo surface and context to render a PDF with.

        pagesize: tuple of page size in meters, see predefined sizes in pagessizes dict (default a4)
        margin: page margin in meters (default 0.01)
        box: box within the page to render the map into (will not render over margin). This should be 
             a Mapnik Box2d object. Default is the full page within the margin
        percent_box: as per box, but specified as a percent (0->1) of the full page size. If both box
                     and percent_box are specified percent_box will be used.
        scale: scale helper to use when rounding the map scale. This should be a function that
               takes a single float and returns a float which is at least as large as the value
               passed in. This is a 1:x scale.
        resolution: the resolution to render non vector elements at (in DPI), defaults to 72 DPI
        preserve_aspect: whether to preserve map aspect ratio. This defaults to True and it
                         is recommended you do not change it unless you know what you are doing
                         scales and so on will not work if this is False.
        centering: Centering rules for maps where the scale rounding has reduced the map size.
                   This should be a value from the centering class. The default is to center on the
                   maps constrained axis, typically this will be horizontal for portrait pages and
                   vertical for landscape pages.
        is_latlon: Is the map in lat lon degrees. If true magic anti meridian logic is enabled
        use_ocg_layers: Create OCG layers in the PDF, requires pyPdf >= 1.13
        """
        self._pagesize = pagesize
        self._margin = margin
        self._box = box
        self._scale = scale
        self._resolution = resolution
        self._preserve_aspect = preserve_aspect
        self._centering = centering
        self._is_latlon = is_latlon
        self._use_ocg_layers = use_ocg_layers

        self._s = None
        self._layer_names = []
        self._filename = None

        self.map_box = None
        self.scale = None

        # don't both to round the scale if they are not preserving the aspect ratio
        if not preserve_aspect:
            self._scale = any_scale

        if percent_box:
            self._box = Box2d(percent_box[0]*pagesize[0],percent_box[1]*pagesize[1],
                         percent_box[2]*pagesize[0],percent_box[3]*pagesize[1])

        if not HAS_PYCAIRO_MODULE:
            raise Exception("PDF rendering only available when pycairo is available")

        self.font_name = "DejaVu Sans"

    def finish(self):
        if self._s:
            self._s.finish()
            self._s = None

        if self._use_ocg_layers:
            convert_pdf_pages_to_layers(self._filename,layer_names=self._layer_names + ["Legend and Information"],reverse_all_but_last=True)

    def add_geospatial_pdf_header(self,m,filename,epsg=None,wkt=None):
        """ Postprocessing step to add geospatial PDF information to PDF file as per
        PDF standard 1.7 extension level 3 (also in draft PDF v2 standard at time of writing)

        one of either the epsg code or wkt text for the projection must be provided

        Should be called *after* the page has had .finish() called"""
        if HAS_PYPDF and (epsg or wkt):
            infile=file(filename,'rb')
            (outfd,outfilename) = tempfile.mkstemp(dir=os.path.dirname(filename))
            outfile = os.fdopen(outfd,'wb')

            i=pyPdf.PdfFileReader(infile)
            o=pyPdf.PdfFileWriter()

            # preserve OCProperties at document root if we have one
            if i.trailer['/Root'].has_key(pyPdf.generic.NameObject('/OCProperties')):
                o._root.getObject()[pyPdf.generic.NameObject('/OCProperties')] = i.trailer['/Root'].getObject()[pyPdf.generic.NameObject('/OCProperties')]

            for p in i.pages:
                gcs = pyPdf.generic.DictionaryObject()
                gcs[pyPdf.generic.NameObject('/Type')]=pyPdf.generic.NameObject('/PROJCS')
                if epsg:
                    gcs[pyPdf.generic.NameObject('/EPSG')]=pyPdf.generic.NumberObject(int(epsg))
                if wkt:
                    gcs[pyPdf.generic.NameObject('/WKT')]=pyPdf.generic.TextStringObject(wkt)

                measure = pyPdf.generic.DictionaryObject()
                measure[pyPdf.generic.NameObject('/Type')]=pyPdf.generic.NameObject('/Measure')
                measure[pyPdf.generic.NameObject('/Subtype')]=pyPdf.generic.NameObject('/GEO')
                measure[pyPdf.generic.NameObject('/GCS')]=gcs
                bounds=pyPdf.generic.ArrayObject()
                for x in (0.0,0.0,0.0,1.0,1.0,1.0,1.0,0.0):
                    bounds.append(pyPdf.generic.FloatObject(str(x)))
                measure[pyPdf.generic.NameObject('/Bounds')]=bounds
                measure[pyPdf.generic.NameObject('/LPTS')]=bounds
                gpts=pyPdf.generic.ArrayObject()

                proj=Projection(m.srs)
                env=m.envelope()
                for x in ((env.minx, env.miny), (env.minx, env.maxy), (env.maxx, env.maxy), (env.maxx, env.miny)):
                    latlon_corner=proj.inverse(Coord(*x))
                    # these are in lat,lon order according to the standard
                    gpts.append(pyPdf.generic.FloatObject(str(latlon_corner.y)))
                    gpts.append(pyPdf.generic.FloatObject(str(latlon_corner.x)))
                measure[pyPdf.generic.NameObject('/GPTS')]=gpts

                vp=pyPdf.generic.DictionaryObject()
                vp[pyPdf.generic.NameObject('/Type')]=pyPdf.generic.NameObject('/Viewport')
                bbox=pyPdf.generic.ArrayObject()

                for x in self.map_box:
                    bbox.append(pyPdf.generic.FloatObject(str(x)))
                vp[pyPdf.generic.NameObject('/BBox')]=bbox
                vp[pyPdf.generic.NameObject('/Measure')]=measure

                vpa = pyPdf.generic.ArrayObject()
                vpa.append(vp)
                p[pyPdf.generic.NameObject('/VP')]=vpa
                o.addPage(p)

            o.write(outfile)
            infile=None
            outfile.close()
            os.rename(outfilename,filename)


    def get_context(self):
        """allow access so that extra 'bits' can be rendered to the page directly"""
        return cairo.Context(self._s)

    def get_width(self):
        return self._pagesize[0]

    def get_height(self):
        return self._pagesize[1]

    def get_margin(self):
        return self._margin

    def write_text(self,ctx,text,box_width=None,size=10, fill_color=(0.0, 0.0, 0.0), alignment=None):
        if HAS_PANGOCAIRO_MODULE:
            (attr,t,accel) = pango.parse_markup(text)
            pctx = pangocairo.CairoContext(ctx)
            l = pctx.create_layout()
            l.set_attributes(attr)
            fd = pango.FontDescription("%s %d" % (self.font_name,size))
            l.set_font_description(fd)
            if box_width:
                l.set_width(int(box_width*pango.SCALE))
            if alignment:
                l.set_alignment(alignment)
            pctx.update_layout(l)
            l.set_text(t)
            pctx.set_source_rgb(*fill_color)
            pctx.show_layout(l)
            return l.get_pixel_extents()[0]

        else:
            ctx.rel_move_to(0,size)
            ctx.select_font_face(self.font_name, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
            ctx.set_font_size(size)
            ctx.show_text(text)
            ctx.rel_move_to(0,size)
            return (0,0,len(text)*size,size)

    def _get_context(self):
        if HAS_PANGOCAIRO_MODULE:
            return 
        elif HAS_PYCAIRO_MODULE:
            return cairo.Context(self._s)
        return None

    def _get_render_area(self):
        """return a bounding box with the area of the page we are allowed to render out map to
        in page coordinates (i.e. meters)
        """
        # take off our page margins
        render_area = Box2d(self._margin,self._margin,self._pagesize[0]-self._margin,self._pagesize[1]-self._margin)

        #then if user specified a box to render get intersection with that
        if self._box:
            return render_area.intersect(self._box)

        return render_area

    def _get_render_area_size(self):
        """Get the width and height (in meters) of the area we can render the map to, returned as a tuple"""
        render_area = self._get_render_area()
        return (render_area.width(),render_area.height())

    def _is_h_contrained(self,m):
        """Test if the map size is constrained on the horizontal or vertical axes"""
        available_area = self._get_render_area_size()
        map_aspect = m.envelope().width()/m.envelope().height()
        page_aspect = available_area[0]/available_area[1]

        return map_aspect > page_aspect

    def _get_meta_info_corner(self,render_size,m):
        """Get the corner (in page coordinates) of a possibly
        sensible place to render metadata such as a legend or scale"""
        (x,y) = self._get_render_corner(render_size,m)
        if self._is_h_contrained(m):
            y += render_size[1]+0.005
            x = self._margin
        else:
            x += render_size[0]+0.005
            y = self._margin

        return (x,y)

    def _get_render_corner(self,render_size,m):
        """Get the corner of the box we should render our map into"""
        available_area = self._get_render_area()

        x=available_area[0]
        y=available_area[1]

        h_is_contrained = self._is_h_contrained(m)

        if (self._centering == centering.both or
            self._centering == centering.horizontal or
            (self._centering == centering.constrained and h_is_contrained) or
            (self._centering == centering.unconstrained and not h_is_contrained)):
            x+=(available_area.width()-render_size[0])/2

        if (self._centering == centering.both or
            self._centering == centering.vertical or
            (self._centering == centering.constrained and not h_is_contrained) or
            (self._centering == centering.unconstrained and h_is_contrained)):
            y+=(available_area.height()-render_size[1])/2
        return (x,y)

    def _get_map_pixel_size(self, width_page_m, height_page_m):
        """for a given map size in paper coordinates return a tuple of the map 'pixel' size we
        should create at the defined resolution"""
        return (int(m2px(width_page_m,self._resolution)), int(m2px(height_page_m,self._resolution)))

    def render_map(self,m, filename):
        """Render the given map to filename"""

        # store this for later so we can post process the PDF
        self._filename = filename

        # work out the best scale to render out map at given the available space
        (eff_width,eff_height) = self._get_render_area_size()
        map_aspect = m.envelope().width()/m.envelope().height()
        page_aspect = eff_width/eff_height

        scalex=m.envelope().width()/eff_width
        scaley=m.envelope().height()/eff_height

        scale=max(scalex,scaley)

        rounded_mapscale=self._scale(scale)
        scalefactor = scale/rounded_mapscale
        mapw=eff_width*scalefactor
        maph=eff_height*scalefactor
        if self._preserve_aspect:
            if map_aspect > page_aspect:
                maph=mapw*(1/map_aspect)
            else:
                mapw=maph*map_aspect

        # set the map size so that raster elements render at the correct resolution
        m.resize(*self._get_map_pixel_size(mapw,maph))
        # calculate the translation for the map starting point
        (tx,ty) = self._get_render_corner((mapw,maph),m)

        # create our cairo surface and context and then render the map into it
        self._s = cairo.PDFSurface(filename, m2pt(self._pagesize[0]),m2pt(self._pagesize[1]))
        ctx=cairo.Context(self._s)

        for l in m.layers:
            # extract the layer names for naming layers if we use OCG
            self._layer_names.append(l.name)

            layer_map = Map(m.width,m.height,m.srs)
            layer_map.layers.append(l)
            for s in l.styles:
                layer_map.append_style(s,m.find_style(s))
            layer_map.zoom_to_box(m.envelope())

            def render_map():
                ctx.save()
                ctx.translate(m2pt(tx),m2pt(ty))
                #cairo defaults to 72dpi
                ctx.scale(72.0/self._resolution,72.0/self._resolution)
                render(layer_map, ctx)
                ctx.restore()

            # antimeridian
            render_map()
            if self._is_latlon and (m.envelope().minx < -180 or m.envelope().maxx > 180):
                old_env = m.envelope()
                if m.envelope().minx < -180:
                    delta = 360
                else:
                    delta = -360
                m.zoom_to_box(Box2d(old_env.minx+delta,old_env.miny,old_env.maxx+delta,old_env.maxy))
                render_map()
                # restore the original env
                m.zoom_to_box(old_env)

            if self._use_ocg_layers:
                self._s.show_page()

        self.scale = rounded_mapscale
        self.map_box = Box2d(tx,ty,tx+mapw,ty+maph)

    def render_on_map_lat_lon_grid(self,m,dec_degrees=True):
        # don't render lat_lon grid if we are already in latlon
        if self._is_latlon:
            return
        p2=Projection(m.srs)

        latlon_bounds = p2.inverse(m.envelope())
        if p2.inverse(m.envelope().center()).x > latlon_bounds.maxx:
            latlon_bounds = Box2d(latlon_bounds.maxx,latlon_bounds.miny,latlon_bounds.minx+360,latlon_bounds.maxy)

        if p2.inverse(m.envelope().center()).y > latlon_bounds.maxy:
            latlon_bounds = Box2d(latlon_bounds.miny,latlon_bounds.maxy,latlon_bounds.maxx,latlon_bounds.miny+360)

        latlon_mapwidth = latlon_bounds.width()
        # render an extra 20% so we generally won't miss the ends of lines
        latlon_buffer = 0.2*latlon_mapwidth
        if dec_degrees:
            latlon_divsize = default_scale(latlon_mapwidth/7.0)
        else:
            latlon_divsize = deg_min_sec_scale(latlon_mapwidth/7.0)
        latlon_interpsize = latlon_mapwidth/m.width

        self._render_lat_lon_axis(m,p2,latlon_bounds.minx,latlon_bounds.maxx,latlon_bounds.miny,latlon_bounds.maxy,latlon_buffer,latlon_interpsize,latlon_divsize,dec_degrees,True)
        self._render_lat_lon_axis(m,p2,latlon_bounds.miny,latlon_bounds.maxy,latlon_bounds.minx,latlon_bounds.maxx,latlon_buffer,latlon_interpsize,latlon_divsize,dec_degrees,False)

    def _render_lat_lon_axis(self,m,p2,x1,x2,y1,y2,latlon_buffer,latlon_interpsize,latlon_divsize,dec_degrees,is_x_axis):
        ctx=cairo.Context(self._s)
        ctx.set_source_rgb(1,0,0)
        ctx.set_line_width(1)
        latlon_labelsize = 6

        ctx.translate(m2pt(self.map_box.minx),m2pt(self.map_box.miny))
        ctx.rectangle(0,0,m2pt(self.map_box.width()),m2pt(self.map_box.height()))
        ctx.clip()

        ctx.select_font_face("DejaVu", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
        ctx.set_font_size(latlon_labelsize)

        box_top = self.map_box.height()
        if not is_x_axis:
            ctx.translate(m2pt(self.map_box.width()/2),m2pt(self.map_box.height()/2))
            ctx.rotate(-math.pi/2)
            ctx.translate(-m2pt(self.map_box.height()/2),-m2pt(self.map_box.width()/2))
            box_top = self.map_box.width()

        for xvalue in round_grid_generator(x1 - latlon_buffer,x2 + latlon_buffer,latlon_divsize):
            yvalue = y1 - latlon_buffer
            start_cross = None
            end_cross = None
            while yvalue < y2+latlon_buffer:
                if is_x_axis:
                    start = m.view_transform().forward(p2.forward(Coord(xvalue,yvalue)))
                else:
                    temp = m.view_transform().forward(p2.forward(Coord(yvalue,xvalue)))
                    start = Coord(m2pt(self.map_box.height())-temp.y,temp.x)
                yvalue += latlon_interpsize
                if is_x_axis:
                    end = m.view_transform().forward(p2.forward(Coord(xvalue,yvalue)))
                else:
                    temp = m.view_transform().forward(p2.forward(Coord(yvalue,xvalue)))
                    end = Coord(m2pt(self.map_box.height())-temp.y,temp.x)

                ctx.move_to(start.x,start.y)
                ctx.line_to(end.x,end.y)
                ctx.stroke()

                if cmp(start.y, 0) != cmp(end.y,0):
                    start_cross = end.x
                if cmp(start.y,m2pt(self.map_box.height())) != cmp(end.y, m2pt(self.map_box.height())):
                    end_cross = end.x

            if dec_degrees:
                line_text = "%g" % (xvalue)
            else:
                line_text = format_deg_min_sec(xvalue)
            if start_cross:
                ctx.move_to(start_cross+2,latlon_labelsize)
                ctx.show_text(line_text)
            if end_cross:
                ctx.move_to(end_cross+2,m2pt(box_top)-2)
                ctx.show_text(line_text)

    def render_on_map_scale(self,m):
        (div_size,page_div_size) = self._get_sensible_scalebar_size(m)

        first_value_x = (math.floor(m.envelope().minx / div_size) + 1) * div_size
        first_value_x_percent = (first_value_x-m.envelope().minx)/m.envelope().width()
        self._render_scale_axis(first_value_x,first_value_x_percent,self.map_box.minx,self.map_box.maxx,page_div_size,div_size,self.map_box.miny,self.map_box.maxy,True)

        first_value_y = (math.floor(m.envelope().miny / div_size) + 1) * div_size
        first_value_y_percent = (first_value_y-m.envelope().miny)/m.envelope().height()
        self._render_scale_axis(first_value_y,first_value_y_percent,self.map_box.miny,self.map_box.maxy,page_div_size,div_size,self.map_box.minx,self.map_box.maxx,False)

        if self._use_ocg_layers:
            self._s.show_page()
            self._layer_names.append("Coordinate Grid Overlay")

    def _get_sensible_scalebar_size(self,m,width=-1):
        # aim for about 8 divisions across the map
        # also make sure we can fit the bar with in page area width if specified
        div_size = sequence_scale(m.envelope().width()/8, [1,2,5])
        page_div_size = self.map_box.width()*div_size/m.envelope().width()
        while width > 0 and page_div_size > width:
            div_size /=2
            page_div_size /= 2
        return (div_size,page_div_size)

    def _render_box(self,ctx,x,y,w,h,text=None,stroke_color=(0,0,0),fill_color=(0,0,0)):
        ctx.set_line_width(1)
        ctx.set_source_rgb(*fill_color)
        ctx.rectangle(x,y,w,h)
        ctx.fill()

        ctx.set_source_rgb(*stroke_color)
        ctx.rectangle(x,y,w,h)
        ctx.stroke()

        if text:
            ctx.move_to(x+1,y)
            self.write_text(ctx,text,fill_color=[1-z for z in fill_color],size=h-2)

    def _render_scale_axis(self,first,first_percent,start,end,page_div_size,div_size,boundary_start,boundary_end,is_x_axis):
        prev = start
        text = None
        fill=(0,0,0)
        border_size=8
        value = first_percent * (end-start) + start
        label_value = first-div_size
        if self._is_latlon and label_value < -180:
            label_value += 360

        ctx=cairo.Context(self._s)

        if not is_x_axis:
            ctx.translate(m2pt(self.map_box.center().x),m2pt(self.map_box.center().y))
            ctx.rotate(-math.pi/2)
            ctx.translate(-m2pt(self.map_box.center().y),-m2pt(self.map_box.center().x))

        while value < end:
            ctx.move_to(m2pt(value),m2pt(boundary_start))
            ctx.line_to(m2pt(value),m2pt(boundary_end))
            ctx.set_source_rgb(0.5,0.5,0.5)
            ctx.set_line_width(1)
            ctx.stroke()

            for bar in (m2pt(boundary_start)-border_size,m2pt(boundary_end)):
                self._render_box(ctx,m2pt(prev),bar,m2pt(value-prev),border_size,text,fill_color=fill)

            prev = value
            value+=page_div_size
            fill = [1-z for z in fill]
            label_value += div_size 
            if self._is_latlon and label_value > 180:
                label_value -= 360
            text = "%d" % label_value
        else:
            for bar in (m2pt(boundary_start)-border_size,m2pt(boundary_end)):
                self._render_box(ctx,m2pt(prev),bar,m2pt(end-prev),border_size,fill_color=fill)


    def render_scale(self,m,ctx=None,width=0.05):
        """ m: map to render scale for
        ctx: A cairo context to render the scale to. If this is None (the default) then
            automatically create a context and choose the best location for the scale bar.
        width: Width of area available to render scale bar in (in m)

        will return the size of the rendered scale block in pts
        """

        (w,h) = (0,0)

        # don't render scale if we are lat lon
        # dont report scale if we have warped the aspect ratio
        if self._preserve_aspect and not self._is_latlon:
            bar_size=8.0
            box_count=3
            if ctx is None:
                ctx=cairo.Context(self._s)
                (tx,ty) = self._get_meta_info_corner((self.map_box.width(),self.map_box.height()),m)
                ctx.translate(tx,ty)

            (div_size,page_div_size) = self._get_sensible_scalebar_size(m, width/box_count)


            div_unit = "m"
            if div_size > 1000:
                div_size /= 1000
                div_unit = "km"

            text = "0%s" % div_unit
            ctx.save()
            if width > 0:
                ctx.translate(m2pt(width-box_count*page_div_size)/2,0)
            for ii in range(box_count):
                fill=(ii%2,)*3
                self._render_box(ctx, m2pt(ii*page_div_size), h, m2pt(page_div_size), bar_size, text, fill_color=fill)
                fill = [1-z for z in fill]
                text = "%g%s" % ((ii+1)*div_size,div_unit)
            #else:
            #    self._render_box(ctx, m2pt(box_count*page_div_size), h, m2pt(page_div_size), bar_size, text, fill_color=(1,1,1), stroke_color=(1,1,1))
            w = (box_count)*page_div_size
            h += bar_size
            ctx.restore()

            if width > 0:
                box_width=m2pt(width)
            else:
                box_width = None

            font_size=6
            ctx.move_to(0,h)
            if HAS_PANGOCAIRO_MODULE:
                alignment = pango.ALIGN_CENTER
            else:
                alignment = None

            text_ext=self.write_text(ctx,"Scale 1:%d" % self.scale,box_width=box_width,size=font_size, alignment=alignment)
            h+=text_ext[3]+2

        return (w,h)

    def render_legend(self,m, page_break=False, ctx=None, collumns=1,width=None, height=None, item_per_rule=False, attribution={}, legend_item_box_size=(0.015,0.0075)):
        """ m: map to render legend for
        ctx: A cairo context to render the legend to. If this is None (the default) then
            automatically create a context and choose the best location for the legend.
        width: Width of area available to render legend in (in m)
        page_break: move to next page if legen over flows this one
        collumns: number of collumns available in legend box
        attribution: additional text that will be rendered in gray under the layer name. keyed by layer name
        legend_item_box_size:  two tuple with width and height of legend item box size in meters

        will return the size of the rendered block in pts
        """

        (w,h) = (0,0)
        if self._s:
            if ctx is None:
                ctx=cairo.Context(self._s)
                (tx,ty) = self._get_meta_info_corner((self.map_box.width(),self.map_box.height()),m)
                ctx.translate(m2pt(tx),m2pt(ty))
                width = self._pagesize[0]-2*tx
                height = self._pagesize[1]-self._margin-ty

            x=0
            y=0
            if width:
                cwidth = width/collumns
                w=m2pt(width)
            else:
                cwidth = None
            current_collumn = 0

            processed_layers = []
            for l in reversed(m.layers):
                have_layer_header = False
                added_styles={}
                layer_title = l.name
                if layer_title in processed_layers:
                    continue
                processed_layers.append(layer_title)

                # check through the features to find which combinations of styles are active
                # for each unique combination add a legend entry
                for f in l.datasource.all_features():
                    if f.num_geometries() > 0:
                        active_rules = []
                        rule_text = ""
                        for s in l.styles:
                            st = m.find_style(s)
                            for r in st.rules:
                                # we need to do the scale test here as well so we don't
                                # add unused scale rules to the legend description
                                if ((not r.filter) or r.filter.evaluate(f) == '1') and \
                                    r.min_scale <= m.scale_denominator() and m.scale_denominator() < r.max_scale:
                                    active_rules.append((s,r.name))
                                    if r.filter and str(r.filter) != "true":
                                        if len(rule_text) > 0:
                                            rule_text += " AND "
                                        if r.name:
                                            rule_text += r.name
                                        else:
                                            rule_text += str(r.filter)
                        active_rules = tuple(active_rules)
                        if added_styles.has_key(active_rules):
                            continue

                        added_styles[active_rules] = (f,rule_text)
                        if not item_per_rule:
                            break
                    else:
                        added_styles[l] = (None,None)

                legend_items = added_styles.keys()
                legend_items.sort()
                for li in legend_items:
                    if True:
                        (f,rule_text) = added_styles[li]


                        legend_map_size = (int(m2pt(legend_item_box_size[0])),int(m2pt(legend_item_box_size[1])))
                        lemap=Map(legend_map_size[0],legend_map_size[1],srs=m.srs)
                        if m.background:
                            lemap.background = m.background
                        # the buffer is needed to ensure that text labels that overflow the edge of the
                        # map still render for the legend
                        lemap.buffer_size=1000
                        for s in l.styles:
                            sty=m.find_style(s)
                            lestyle = Style()
                            for r in sty.rules:
                                for sym in r.symbols:
                                    try:
                                        sym.avoid_edges=False
                                    except:
                                        print "**** Cant set avoid edges for rule", r.name
                                if r.min_scale <= m.scale_denominator() and m.scale_denominator() < r.max_scale:
                                    lerule = r
                                    lerule.min_scale = 0
                                    lerule.max_scale = float("inf")
                                    lestyle.rules.append(lerule)
                            lemap.append_style(s,lestyle)

                        ds = MemoryDatasource()
                        if f is None:
                            ds=l.datasource
                            layer_srs = l.srs
                        elif f.envelope().width() == 0:
                            ds.add_feature(Feature(f.id(),Geometry2d.from_wkt("POINT(0 0)"),**f.attributes))
                            lemap.zoom_to_box(Box2d(-1,-1,1,1))
                            layer_srs = m.srs
                        else:
                            ds.add_feature(f)
                            layer_srs = l.srs

                        lelayer = Layer("LegendLayer",layer_srs)
                        lelayer.datasource = ds
                        for s in l.styles:
                            lelayer.styles.append(s)
                        lemap.layers.append(lelayer)

                        if f is None or f.envelope().width() != 0:
                            lemap.zoom_all()
                            lemap.zoom(1.1)

                        item_size = legend_map_size[1]
                        if not have_layer_header:
                            item_size += 8

                        if y+item_size > m2pt(height):
                            current_collumn += 1
                            y=0
                            if current_collumn >= collumns:
                                if page_break:
                                    self._s.show_page()
                                    x=0
                                    current_collumn = 0
                                else:
                                    break

                        if not have_layer_header and item_per_rule:
                            ctx.move_to(x+m2pt(current_collumn*cwidth),y)
                            e=self.write_text(ctx, l.name, m2pt(cwidth), 8)
                            y+=e[3]+2
                            have_layer_header = True
                        ctx.save()
                        ctx.translate(x+m2pt(current_collumn*cwidth),y)
                        #extra save around map render as it sets up a clip box and doesn't clear it
                        ctx.save()
                        render(lemap, ctx)
                        ctx.restore()

                        ctx.rectangle(0,0,*legend_map_size)
                        ctx.set_source_rgb(0.5,0.5,0.5)
                        ctx.set_line_width(1)
                        ctx.stroke()
                        ctx.restore()

                        ctx.move_to(x+legend_map_size[0]+m2pt(current_collumn*cwidth)+2,y)
                        legend_entry_size = legend_map_size[1]
                        legend_text_size = 0
                        if not item_per_rule:
                            rule_text = layer_title
                        if rule_text:
                            e=self.write_text(ctx, rule_text, m2pt(cwidth-legend_item_box_size[0]-0.005), 6)
                            legend_text_size += e[3]
                            ctx.rel_move_to(0,e[3])
                        if attribution.has_key(layer_title):
                            e=self.write_text(ctx, attribution[layer_title], m2pt(cwidth-legend_item_box_size[0]-0.005), 6, fill_color=(0.5,0.5,0.5))
                            legend_text_size += e[3]

                        if legend_text_size > legend_entry_size:
                            legend_entry_size=legend_text_size

                        y+=legend_entry_size +2
                        if y > h:
                            h = y
        return (w,h)