# -*- 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, print_function

import math

import os

import tempfile

from . import (Box2d, Coord, Feature, Geometry, Layer, Map, Projection, Style,

render)

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 pyPdf.generic.NameObject('/OCProperties') in i.trailer['/Root']:

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