def __init__(self, db, rc, tmpdir, dpi, file_prefix, index_position="side"):
"""
Create the renderer.
Args:
rc (RenderingConfiguration): rendering parameters.
tmpdir (os.path): Path to a temp dir that can hold temp files.
index_position (str): None or 'side' (index on side),
'bottom' (index at bottom).
"""
Renderer.__init__(self, db, rc, tmpdir, dpi)
# Prepare the index
self.street_index = StreetIndex(db, rc.polygon_wkt, rc.i18n)
if not self.street_index.categories:
LOG.warning("Designated area leads to an empty index")
self.street_index = None
self._grid_legend_margin_pt = min(
Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_width_pt,
Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_height_pt,
)
self._title_margin_pt = 0.05 * self.paper_height_pt
self._copyright_margin_pt = 0.02 * self.paper_height_pt
self._usable_area_width_pt = self.paper_width_pt - 2 * Renderer.PRINT_SAFE_MARGIN_PT
self._usable_area_height_pt = self.paper_height_pt - (
2 * Renderer.PRINT_SAFE_MARGIN_PT + self._title_margin_pt + self._copyright_margin_pt
)
# Prepare the Index (may raise a IndexDoesNotFitError)
if index_position and self.street_index and self.street_index.categories:
self._index_renderer, self._index_area = self._create_index_rendering(index_position == "side")
else:
self._index_renderer, self._index_area = None, None
# Prepare the layout of the whole page
if not self._index_area:
# No index displayed
self._map_coords = (
Renderer.PRINT_SAFE_MARGIN_PT,
(Renderer.PRINT_SAFE_MARGIN_PT + self._title_margin_pt),
self._usable_area_width_pt,
self._usable_area_height_pt,
)
elif index_position == "side":
# Index present, displayed on the side
if self._index_area.x > Renderer.PRINT_SAFE_MARGIN_PT:
# Index on the right -> map on the left
self._map_coords = (
Renderer.PRINT_SAFE_MARGIN_PT,
(Renderer.PRINT_SAFE_MARGIN_PT + self._title_margin_pt),
(self._usable_area_width_pt - self._index_area.w),
self._usable_area_height_pt,
)
else:
# Index on the left -> map on the right
self._map_coords = (
self._index_area.x + self._index_area.w,
(Renderer.PRINT_SAFE_MARGIN_PT + self._title_margin_pt),
(self._usable_area_width_pt - self._index_area.w),
self._usable_area_height_pt,
)
elif index_position == "bottom":
# Index present, displayed at the bottom -> map on top
self._map_coords = (
Renderer.PRINT_SAFE_MARGIN_PT,
(Renderer.PRINT_SAFE_MARGIN_PT + self._title_margin_pt),
self._usable_area_width_pt,
(self._usable_area_height_pt - self._index_area.h),
)
else:
raise AssertionError("Invalid index position %s" % repr(index_position))
# Prepare the map
self._map_canvas = self._create_map_canvas(
float(self._map_coords[2]), float(self._map_coords[3]), dpi, rc.osmid is not None # W # H
)
# Prepare map overlay
if self.rc.overlay:
self._overlay_canvas = MapCanvas(
self.rc.overlay,
self.rc.bounding_box,
float(self._map_coords[2]), # W
float(self._map_coords[3]), # H
dpi,
)
# Prepare map overlay
if self.rc.overlay:
self._overlay_canvas = MapCanvas(
self.rc.overlay,
self.rc.bounding_box,
float(self._map_coords[2]), # W
float(self._map_coords[3]), # H
dpi,
)
# Prepare map overlay
if self.rc.overlay:
self._overlay_canvas = MapCanvas(
self.rc.overlay,
self.rc.bounding_box,
float(self._map_coords[2]), # W
float(self._map_coords[3]), # H
dpi,
)
# Prepare the grid
self.grid = self._create_grid(self._map_canvas, dpi)
# Update the street_index to reflect the grid's actual position
if self.grid and self.street_index:
self.street_index.apply_grid(self.grid)
# Dump the CSV street index
if self.street_index:
self.street_index.write_to_csv(rc.title, "%s.csv" % file_prefix)
# Commit the internal rendering stack of the map
self._map_canvas.render()
if self.rc.overlay:
self._overlay_canvas.render()
def __init__(self, db, rc, tmpdir, dpi, file_prefix,
index_position = 'side'):
"""
Create the renderer.
Args:
rc (RenderingConfiguration): rendering parameters.
tmpdir (os.path): Path to a temp dir that can hold temp files.
index_position (str): None or 'side' (index on side),
'bottom' (index at bottom).
"""
Renderer.__init__(self, db, rc, tmpdir, dpi)
# Prepare the index
self.street_index = StreetIndex(db,
rc.polygon_wkt,
rc.i18n)
if not self.street_index.categories:
LOG.warning("Designated area leads to an empty index")
self.street_index = None
self._grid_legend_margin_pt = \
min(Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_width_pt,
Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_height_pt)
self._title_margin_pt = 0.05 * self.paper_height_pt
self._copyright_margin_pt = 0.02 * self.paper_height_pt
self._usable_area_width_pt = (self.paper_width_pt -
2 * Renderer.PRINT_SAFE_MARGIN_PT)
self._usable_area_height_pt = (self.paper_height_pt -
(2 * Renderer.PRINT_SAFE_MARGIN_PT +
self._title_margin_pt +
self._copyright_margin_pt))
# Prepare the Index (may raise a IndexDoesNotFitError)
if ( index_position and self.street_index
and self.street_index.categories ):
self._index_renderer, self._index_area \
= self._create_index_rendering(index_position == "side")
else:
self._index_renderer, self._index_area = None, None
# Prepare the layout of the whole page
if not self._index_area:
# No index displayed
self._map_coords = ( Renderer.PRINT_SAFE_MARGIN_PT,
( Renderer.PRINT_SAFE_MARGIN_PT
+ self._title_margin_pt ),
self._usable_area_width_pt,
self._usable_area_height_pt )
elif index_position == 'side':
# Index present, displayed on the side
if self._index_area.x > Renderer.PRINT_SAFE_MARGIN_PT:
# Index on the right -> map on the left
self._map_coords = ( Renderer.PRINT_SAFE_MARGIN_PT,
( Renderer.PRINT_SAFE_MARGIN_PT
+ self._title_margin_pt ),
( self._usable_area_width_pt
- self._index_area.w ),
self._usable_area_height_pt )
else:
# Index on the left -> map on the right
self._map_coords = ( self._index_area.x + self._index_area.w,
( Renderer.PRINT_SAFE_MARGIN_PT
+ self._title_margin_pt ),
( self._usable_area_width_pt
- self._index_area.w ),
self._usable_area_height_pt )
elif index_position == 'bottom':
# Index present, displayed at the bottom -> map on top
self._map_coords = ( Renderer.PRINT_SAFE_MARGIN_PT,
( Renderer.PRINT_SAFE_MARGIN_PT
+ self._title_margin_pt ),
self._usable_area_width_pt,
( self._usable_area_height_pt
- self._index_area.h ) )
else:
raise AssertionError("Invalid index position %s"
% repr(index_position))
# Prepare the map
self._map_canvas = self._create_map_canvas(
float(self._map_coords[2]), # W
float(self._map_coords[3]), # H
dpi )
# Prepare the grid
self.grid = self._create_grid(self._map_canvas)
# Update the street_index to reflect the grid's actual position
if self.grid and self.street_index:
self.street_index.apply_grid(self.grid)
# Dump the CSV street index
if self.street_index:
self.street_index.write_to_csv(rc.title, '%s.csv' % file_prefix)
# Commit the internal rendering stack of the map
self._map_canvas.render()
def __init__(self, db, rc, tmpdir, dpi, file_prefix):
Renderer.__init__(self, db, rc, tmpdir, dpi)
self._grid_legend_margin_pt = \
min(Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_width_pt,
Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_height_pt)
# Compute the usable area per page
self._usable_area_width_pt = (self.paper_width_pt -
(2 * Renderer.PRINT_SAFE_MARGIN_PT))
self._usable_area_height_pt = (self.paper_height_pt -
(2 * Renderer.PRINT_SAFE_MARGIN_PT))
scale_denom = Renderer.DEFAULT_SCALE
# the mapnik scale depends on the latitude. However we are
# always using Mapnik conversion functions (lat,lon <->
# mercator_meters) so we don't need to take into account
# latitude in following computations
# by convention, mapnik uses 90 ppi whereas cairo uses 72 ppi
scale_denom *= float(72) / 90
GRAYED_MARGIN_MM = 10
OVERLAP_MARGIN_MM = 20
# Debug: show original bounding box as JS code
# print self.rc.bounding_box.as_javascript("original", "#00ff00")
# Convert the original Bounding box into Mercator meters
self._proj = mapnik.Projection(coords._MAPNIK_PROJECTION)
orig_envelope = self._project_envelope(self.rc.bounding_box)
# Extend the bounding box to take into account the lost outter
# margin
off_x = orig_envelope.minx - (GRAYED_MARGIN_MM * scale_denom) / 1000
off_y = orig_envelope.miny - (GRAYED_MARGIN_MM * scale_denom) / 1000
width = orig_envelope.width() + (2 * GRAYED_MARGIN_MM *
scale_denom) / 1000
height = orig_envelope.height() + (2 * GRAYED_MARGIN_MM *
scale_denom) / 1000
# Calculate the total width and height of paper needed to
# render the geographical area at the current scale.
total_width_pt = commons.convert_mm_to_pt(
float(width) * 1000 / scale_denom)
total_height_pt = commons.convert_mm_to_pt(
float(height) * 1000 / scale_denom)
self.grayed_margin_pt = commons.convert_mm_to_pt(GRAYED_MARGIN_MM)
overlap_margin_pt = commons.convert_mm_to_pt(OVERLAP_MARGIN_MM)
# Calculate the number of pages needed in both directions
if total_width_pt < self._usable_area_width_pt:
nb_pages_width = 1
else:
nb_pages_width = \
(float(total_width_pt - self._usable_area_width_pt) / \
(self._usable_area_width_pt - overlap_margin_pt)) + 1
if total_height_pt < self._usable_area_height_pt:
nb_pages_height = 1
else:
nb_pages_height = \
(float(total_height_pt - self._usable_area_height_pt) / \
(self._usable_area_height_pt - overlap_margin_pt)) + 1
# Round up the number of pages needed so that we have integer
# number of pages
self.nb_pages_width = int(math.ceil(nb_pages_width))
self.nb_pages_height = int(math.ceil(nb_pages_height))
# Calculate the entire paper area available
total_width_pt_after_extension = self._usable_area_width_pt + \
(self._usable_area_width_pt - overlap_margin_pt) * (self.nb_pages_width - 1)
total_height_pt_after_extension = self._usable_area_height_pt + \
(self._usable_area_height_pt - overlap_margin_pt) * (self.nb_pages_height - 1)
# Convert this paper area available in the number of Mercator
# meters that can be rendered on the map
total_width_merc = \
commons.convert_pt_to_mm(total_width_pt_after_extension) * scale_denom / 1000
total_height_merc = \
commons.convert_pt_to_mm(total_height_pt_after_extension) * scale_denom / 1000
# Extend the geographical boundaries so that we completely
# fill the available paper size. We are careful to extend the
# boundaries evenly on all directions (so the center of the
# previous boundaries remain the same as the new one)
off_x -= (total_width_merc - width) / 2
width = total_width_merc
off_y -= (total_height_merc - height) / 2
height = total_height_merc
# Calculate what is the final global bounding box that we will render
envelope = mapnik.Box2d(off_x, off_y, off_x + width, off_y + height)
self._geo_bbox = self._inverse_envelope(envelope)
# Debug: show transformed bounding box as JS code
# print self._geo_bbox.as_javascript("extended", "#0f0f0f")
# Convert the usable area on each sheet of paper into the
# amount of Mercator meters we can render in this area.
usable_area_merc_m_width = commons.convert_pt_to_mm(
self._usable_area_width_pt) * scale_denom / 1000
usable_area_merc_m_height = commons.convert_pt_to_mm(
self._usable_area_height_pt) * scale_denom / 1000
grayed_margin_merc_m = (GRAYED_MARGIN_MM * scale_denom) / 1000
overlap_margin_merc_m = (OVERLAP_MARGIN_MM * scale_denom) / 1000
# Calculate all the bounding boxes that correspond to the
# geographical area that will be rendered on each sheet of
# paper.
area_polygon = shapely.wkt.loads(self.rc.polygon_wkt)
bboxes = []
self.page_disposition, map_number = {}, 0
for j in reversed(range(0, self.nb_pages_height)):
col = self.nb_pages_height - j - 1
self.page_disposition[col] = []
for i in range(0, self.nb_pages_width):
cur_x = off_x + i * (usable_area_merc_m_width -
overlap_margin_merc_m)
cur_y = off_y + j * (usable_area_merc_m_height -
overlap_margin_merc_m)
envelope = mapnik.Box2d(cur_x, cur_y,
cur_x + usable_area_merc_m_width,
cur_y + usable_area_merc_m_height)
envelope_inner = mapnik.Box2d(
cur_x + grayed_margin_merc_m, cur_y + grayed_margin_merc_m,
cur_x + usable_area_merc_m_width - grayed_margin_merc_m,
cur_y + usable_area_merc_m_height - grayed_margin_merc_m)
inner_bb = self._inverse_envelope(envelope_inner)
if not area_polygon.disjoint(
shapely.wkt.loads(inner_bb.as_wkt())):
self.page_disposition[col].append(map_number)
map_number += 1
bboxes.append((self._inverse_envelope(envelope), inner_bb))
else:
self.page_disposition[col].append(None)
# Debug: show per-page bounding boxes as JS code
# for i, (bb, bb_inner) in enumerate(bboxes):
# print bb.as_javascript(name="p%d" % i)
self.pages = []
# Create an overview map
overview_bb = self._geo_bbox.create_expanded(0.001, 0.001)
# Create the overview grid
self.overview_grid = OverviewGrid(
overview_bb, [bb_inner for bb, bb_inner in bboxes],
self.rc.i18n.isrtl())
grid_shape = self.overview_grid.generate_shape_file(
os.path.join(self.tmpdir, 'grid_overview.shp'))
# Create a canvas for the overview page
self.overview_canvas = MapCanvas(self.rc.stylesheet,
overview_bb,
self._usable_area_width_pt,
self._usable_area_height_pt,
dpi,
extend_bbox_to_ratio=True)
# Create the gray shape around the overview map
exterior = shapely.wkt.loads(self.overview_canvas.get_actual_bounding_box()\
.as_wkt())
interior = shapely.wkt.loads(self.rc.polygon_wkt)
shade_wkt = exterior.difference(interior).wkt
shade = maplib.shapes.PolyShapeFile(
self.rc.bounding_box,
os.path.join(self.tmpdir, 'shape_overview.shp'), 'shade-overview')
shade.add_shade_from_wkt(shade_wkt)
self.overview_canvas.add_shape_file(shade)
self.overview_canvas.add_shape_file(grid_shape,
self.rc.stylesheet.grid_line_color,
1,
self.rc.stylesheet.grid_line_width)
self.overview_canvas.render()
# Create the map canvas for each page
indexes = []
for i, (bb, bb_inner) in enumerate(bboxes):
# Create the gray shape around the map
exterior = shapely.wkt.loads(bb.as_wkt())
interior = shapely.wkt.loads(bb_inner.as_wkt())
shade_wkt = exterior.difference(interior).wkt
shade = maplib.shapes.PolyShapeFile(
bb, os.path.join(self.tmpdir, 'shade%d.shp' % i),
'shade%d' % i)
shade.add_shade_from_wkt(shade_wkt)
# Create the contour shade
# Area to keep visible
interior_contour = shapely.wkt.loads(self.rc.polygon_wkt)
# Determine the shade WKT
shade_contour_wkt = interior.difference(interior_contour).wkt
# Prepare the shade SHP
shade_contour = maplib.shapes.PolyShapeFile(
bb, os.path.join(self.tmpdir, 'shade_contour%d.shp' % i),
'shade_contour%d' % i)
shade_contour.add_shade_from_wkt(shade_contour_wkt)
# Create one canvas for the current page
map_canvas = MapCanvas(self.rc.stylesheet,
bb,
self._usable_area_width_pt,
self._usable_area_height_pt,
dpi,
extend_bbox_to_ratio=False)
# Create canvas for overlay on current page
overla_canvas = None
if self.rc.overlay:
overlay_canvas = MapCanvas(self.rc.overlay,
bb,
self._usable_area_width_pt,
self._usable_area_height_pt,
dpi,
extend_bbox_to_ratio=False)
# Create the grid
map_grid = Grid(bb_inner, map_canvas.get_actual_scale(),
self.rc.i18n.isrtl())
grid_shape = map_grid.generate_shape_file(
os.path.join(self.tmpdir, 'grid%d.shp' % i))
map_canvas.add_shape_file(shade)
map_canvas.add_shape_file(shade_contour,
self.rc.stylesheet.shade_color_2,
self.rc.stylesheet.shade_alpha_2)
map_canvas.add_shape_file(grid_shape,
self.rc.stylesheet.grid_line_color,
self.rc.stylesheet.grid_line_alpha,
self.rc.stylesheet.grid_line_width)
map_canvas.render()
if overlay_canvas:
overlay_canvas.render()
self.pages.append((map_canvas, map_grid, overlay_canvas))
# Create the index for the current page
inside_contour_wkt = interior_contour.intersection(interior).wkt
index = StreetIndex(self.db,
inside_contour_wkt,
self.rc.i18n,
page_number=(i + 4))
index.apply_grid(map_grid)
indexes.append(index)
# Merge all indexes
self.index_categories = self._merge_page_indexes(indexes)
# Prepare the small map for the front page
self._front_page_map = self._prepare_front_page_map(dpi)
def __init__(self, rc, tmpdir,
street_index = None, index_position = 'side'):
"""
Create the renderer.
Args:
rc (RenderingConfiguration): rendering parameters.
tmpdir (os.path): Path to a temp dir that can hold temp files.
street_index (StreetIndex): None or the street index object.
index_position (str): None or 'side' (index on side),
'bottom' (index at bottom).
"""
Renderer.__init__(self, rc, tmpdir, street_index)
self._grid_legend_margin_pt = \
min(Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_width_pt,
Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_height_pt)
self._title_margin_pt = 0.05 * self.paper_height_pt
self._copyright_margin_pt = 0.02 * self.paper_height_pt
self._usable_area_width_pt = (self.paper_width_pt -
2 * Renderer.PRINT_SAFE_MARGIN_PT)
self._usable_area_height_pt = (self.paper_height_pt -
(2 * Renderer.PRINT_SAFE_MARGIN_PT +
self._title_margin_pt +
self._copyright_margin_pt))
# Prepare the Index (may raise a IndexDoesNotFitError)
if ( index_position and self.street_index
and self.street_index.categories ):
self._index_renderer, self._index_area \
= self._create_index_rendering(index_position == "side")
else:
self._index_renderer, self._index_area = None, None
# Prepare the layout of the whole page
if not self._index_area:
# No index displayed
self._map_coords = ( Renderer.PRINT_SAFE_MARGIN_PT,
( Renderer.PRINT_SAFE_MARGIN_PT
+ self._title_margin_pt ),
self._usable_area_width_pt,
self._usable_area_height_pt )
elif index_position == 'side':
# Index present, displayed on the side
if self._index_area.x > Renderer.PRINT_SAFE_MARGIN_PT:
# Index on the right -> map on the left
self._map_coords = ( Renderer.PRINT_SAFE_MARGIN_PT,
( Renderer.PRINT_SAFE_MARGIN_PT
+ self._title_margin_pt ),
( self._usable_area_width_pt
- self._index_area.w ),
self._usable_area_height_pt )
else:
# Index on the left -> map on the right
self._map_coords = ( self._index_area.x + self._index_area.w,
( Renderer.PRINT_SAFE_MARGIN_PT
+ self._title_margin_pt ),
( self._usable_area_width_pt
- self._index_area.w ),
self._usable_area_height_pt )
elif index_position == 'bottom':
# Index present, displayed at the bottom -> map on top
self._map_coords = ( Renderer.PRINT_SAFE_MARGIN_PT,
( Renderer.PRINT_SAFE_MARGIN_PT
+ self._title_margin_pt ),
self._usable_area_width_pt,
( self._usable_area_height_pt
- self._index_area.h ) )
else:
raise AssertionError("Invalid index position %s"
% repr(index_position))
# Prepare the map
self._map_canvas = self._create_map_canvas(
(float(self._map_coords[2]), float(self._map_coords[3])) ) # H
# Prepare the grid
self.grid = self._create_grid(self._map_canvas)
# Commit the internal rendering stack of the map
self._map_canvas.render()
def __init__(self, db, rc, tmpdir, dpi, file_prefix):
Renderer.__init__(self, db, rc, tmpdir, dpi)
self._grid_legend_margin_pt = \
min(Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_width_pt,
Renderer.GRID_LEGEND_MARGIN_RATIO * self.paper_height_pt)
# Compute the usable area per page
self._usable_area_width_pt = (self.paper_width_pt -
(2 * Renderer.PRINT_SAFE_MARGIN_PT))
self._usable_area_height_pt = (self.paper_height_pt -
(2 * Renderer.PRINT_SAFE_MARGIN_PT))
scale_denom = Renderer.DEFAULT_SCALE
# the mapnik scale depends on the latitude. However we are
# always using Mapnik conversion functions (lat,lon <->
# mercator_meters) so we don't need to take into account
# latitude in following computations
# by convention, mapnik uses 90 ppi whereas cairo uses 72 ppi
scale_denom *= float(72) / 90
GRAYED_MARGIN_MM = 10
OVERLAP_MARGIN_MM = 20
# Debug: show original bounding box as JS code
# print self.rc.bounding_box.as_javascript("original", "#00ff00")
# Convert the original Bounding box into Mercator meters
self._proj = mapnik.Projection(coords._MAPNIK_PROJECTION)
orig_envelope = self._project_envelope(self.rc.bounding_box)
# Extend the bounding box to take into account the lost outter
# margin
off_x = orig_envelope.minx - (GRAYED_MARGIN_MM * scale_denom) / 1000
off_y = orig_envelope.miny - (GRAYED_MARGIN_MM * scale_denom) / 1000
width = orig_envelope.width() + (2 * GRAYED_MARGIN_MM * scale_denom) / 1000
height = orig_envelope.height() + (2 * GRAYED_MARGIN_MM * scale_denom) / 1000
# Calculate the total width and height of paper needed to
# render the geographical area at the current scale.
total_width_pt = commons.convert_mm_to_pt(float(width) * 1000 / scale_denom)
total_height_pt = commons.convert_mm_to_pt(float(height) * 1000 / scale_denom)
self.grayed_margin_pt = commons.convert_mm_to_pt(GRAYED_MARGIN_MM)
overlap_margin_pt = commons.convert_mm_to_pt(OVERLAP_MARGIN_MM)
# Calculate the number of pages needed in both directions
if total_width_pt < self._usable_area_width_pt:
nb_pages_width = 1
else:
nb_pages_width = \
(float(total_width_pt - self._usable_area_width_pt) / \
(self._usable_area_width_pt - overlap_margin_pt)) + 1
if total_height_pt < self._usable_area_height_pt:
nb_pages_height = 1
else:
nb_pages_height = \
(float(total_height_pt - self._usable_area_height_pt) / \
(self._usable_area_height_pt - overlap_margin_pt)) + 1
# Round up the number of pages needed so that we have integer
# number of pages
self.nb_pages_width = int(math.ceil(nb_pages_width))
self.nb_pages_height = int(math.ceil(nb_pages_height))
# Calculate the entire paper area available
total_width_pt_after_extension = self._usable_area_width_pt + \
(self._usable_area_width_pt - overlap_margin_pt) * (self.nb_pages_width - 1)
total_height_pt_after_extension = self._usable_area_height_pt + \
(self._usable_area_height_pt - overlap_margin_pt) * (self.nb_pages_height - 1)
# Convert this paper area available in the number of Mercator
# meters that can be rendered on the map
total_width_merc = \
commons.convert_pt_to_mm(total_width_pt_after_extension) * scale_denom / 1000
total_height_merc = \
commons.convert_pt_to_mm(total_height_pt_after_extension) * scale_denom / 1000
# Extend the geographical boundaries so that we completely
# fill the available paper size. We are careful to extend the
# boundaries evenly on all directions (so the center of the
# previous boundaries remain the same as the new one)
off_x -= (total_width_merc - width) / 2
width = total_width_merc
off_y -= (total_height_merc - height) / 2
height = total_height_merc
# Calculate what is the final global bounding box that we will render
envelope = mapnik.Box2d(off_x, off_y, off_x + width, off_y + height)
self._geo_bbox = self._inverse_envelope(envelope)
# Debug: show transformed bounding box as JS code
# print self._geo_bbox.as_javascript("extended", "#0f0f0f")
# Convert the usable area on each sheet of paper into the
# amount of Mercator meters we can render in this area.
usable_area_merc_m_width = commons.convert_pt_to_mm(self._usable_area_width_pt) * scale_denom / 1000
usable_area_merc_m_height = commons.convert_pt_to_mm(self._usable_area_height_pt) * scale_denom / 1000
grayed_margin_merc_m = (GRAYED_MARGIN_MM * scale_denom) / 1000
overlap_margin_merc_m = (OVERLAP_MARGIN_MM * scale_denom) / 1000
# Calculate all the bounding boxes that correspond to the
# geographical area that will be rendered on each sheet of
# paper.
area_polygon = shapely.wkt.loads(self.rc.polygon_wkt)
bboxes = []
self.page_disposition, map_number = {}, 0
for j in reversed(range(0, self.nb_pages_height)):
col = self.nb_pages_height - j - 1
self.page_disposition[col] = []
for i in range(0, self.nb_pages_width):
cur_x = off_x + i * (usable_area_merc_m_width - overlap_margin_merc_m)
cur_y = off_y + j * (usable_area_merc_m_height - overlap_margin_merc_m)
envelope = mapnik.Box2d(cur_x, cur_y,
cur_x+usable_area_merc_m_width,
cur_y+usable_area_merc_m_height)
envelope_inner = mapnik.Box2d(cur_x + grayed_margin_merc_m,
cur_y + grayed_margin_merc_m,
cur_x + usable_area_merc_m_width - grayed_margin_merc_m,
cur_y + usable_area_merc_m_height - grayed_margin_merc_m)
inner_bb = self._inverse_envelope(envelope_inner)
if not area_polygon.disjoint(shapely.wkt.loads(
inner_bb.as_wkt())):
self.page_disposition[col].append(map_number)
map_number += 1
bboxes.append((self._inverse_envelope(envelope),
inner_bb))
else:
self.page_disposition[col].append(None)
# Debug: show per-page bounding boxes as JS code
# for i, (bb, bb_inner) in enumerate(bboxes):
# print bb.as_javascript(name="p%d" % i)
self.pages = []
# Create an overview map
overview_bb = self._geo_bbox.create_expanded(0.001, 0.001)
# Create the overview grid
self.overview_grid = OverviewGrid(overview_bb,
[bb_inner for bb, bb_inner in bboxes], self.rc.i18n.isrtl())
grid_shape = self.overview_grid.generate_shape_file(
os.path.join(self.tmpdir, 'grid_overview.shp'))
# Create a canvas for the overview page
self.overview_canvas = MapCanvas(self.rc.stylesheet,
overview_bb, self._usable_area_width_pt,
self._usable_area_height_pt, dpi,
extend_bbox_to_ratio=True)
# Create the gray shape around the overview map
exterior = shapely.wkt.loads(self.overview_canvas.get_actual_bounding_box()\
.as_wkt())
interior = shapely.wkt.loads(self.rc.polygon_wkt)
shade_wkt = exterior.difference(interior).wkt
shade = maplib.shapes.PolyShapeFile(self.rc.bounding_box,
os.path.join(self.tmpdir, 'shape_overview.shp'),
'shade-overview')
shade.add_shade_from_wkt(shade_wkt)
self.overview_canvas.add_shape_file(shade)
self.overview_canvas.add_shape_file(grid_shape,
self.rc.stylesheet.grid_line_color, 1,
self.rc.stylesheet.grid_line_width)
self.overview_canvas.render()
# Create the map canvas for each page
indexes = []
for i, (bb, bb_inner) in enumerate(bboxes):
# Create the gray shape around the map
exterior = shapely.wkt.loads(bb.as_wkt())
interior = shapely.wkt.loads(bb_inner.as_wkt())
shade_wkt = exterior.difference(interior).wkt
shade = maplib.shapes.PolyShapeFile(
bb, os.path.join(self.tmpdir, 'shade%d.shp' % i),
'shade%d' % i)
shade.add_shade_from_wkt(shade_wkt)
# Create the contour shade
# Area to keep visible
interior_contour = shapely.wkt.loads(self.rc.polygon_wkt)
# Determine the shade WKT
shade_contour_wkt = interior.difference(interior_contour).wkt
# Prepare the shade SHP
shade_contour = maplib.shapes.PolyShapeFile(bb,
os.path.join(self.tmpdir, 'shade_contour%d.shp' % i),
'shade_contour%d' % i)
shade_contour.add_shade_from_wkt(shade_contour_wkt)
# Create one canvas for the current page
map_canvas = MapCanvas(self.rc.stylesheet,
bb, self._usable_area_width_pt,
self._usable_area_height_pt, dpi,
extend_bbox_to_ratio=False)
# Create the grid
map_grid = Grid(bb_inner, map_canvas.get_actual_scale(), self.rc.i18n.isrtl())
grid_shape = map_grid.generate_shape_file(
os.path.join(self.tmpdir, 'grid%d.shp' % i))
map_canvas.add_shape_file(shade)
map_canvas.add_shape_file(shade_contour,
self.rc.stylesheet.shade_color_2,
self.rc.stylesheet.shade_alpha_2)
map_canvas.add_shape_file(grid_shape,
self.rc.stylesheet.grid_line_color,
self.rc.stylesheet.grid_line_alpha,
self.rc.stylesheet.grid_line_width)
map_canvas.render()
self.pages.append((map_canvas, map_grid))
# Create the index for the current page
inside_contour_wkt = interior_contour.intersection(interior).wkt
index = StreetIndex(self.db,
inside_contour_wkt,
self.rc.i18n, page_number=(i + 4))
index.apply_grid(map_grid)
indexes.append(index)
# Merge all indexes
self.index_categories = self._merge_page_indexes(indexes)
# Prepare the small map for the front page
self._front_page_map = self._prepare_front_page_map(dpi)