def layerRenderByComposer(self, layer, outName):
self.hideOtherLayers(layer)
mapRenderer = self.iface.mapCanvas().mapRenderer()
mapRenderer.setLayerSet([layer.id()])
c = QgsComposition(mapRenderer)
c.setPlotStyle(QgsComposition.Print)
c.setPaperSize(297, 210)
c.setPrintResolution(300)
x, y = 0, 0
w, h = c.paperWidth(), c.paperHeight()
composerMap = QgsComposerMap(c, x, y, w, h)
composerMap.setMapCanvas(self.iface.mapCanvas())
c.addItem(composerMap)
legend = QgsComposerLegend(c)
root = QgsProject.instance().layerTreeRoot().clone()
root = self.buildLegendLayerTree(root, [layer])
legend.modelV2().setRootGroup(root)
legend.setItemPosition(250, 20)
legend.setResizeToContents(True)
c.addItem(legend)
label = QgsComposerLabel(c)
label.setMarginX(125)
label.setMarginY(10)
label.setText(layer.name())
label.setFont(QFont('PMinliu', 20, QFont.Bold))
label.adjustSizeToText()
c.addItem(label)
item = QgsComposerScaleBar(c)
item.setStyle('Double Box') # optionally modify the style
item.setComposerMap(composerMap)
item.applyDefaultSize()
item.setItemPosition(10, 190)
c.addItem(item)
dpmm = 300 / 25.4
width = int(dpmm * c.paperWidth())
width = int(width / 2) * 2
height = int(dpmm * c.paperHeight())
height = int(height / 2) * 2
Dots = int(dpmm * 1000 / 2) * 2
# create output image and initialize it
image = QImage(QSize(width, height), QImage.Format_ARGB32)
image.setDotsPerMeterX(Dots)
image.setDotsPerMeterY(Dots)
image.fill(0)
# render the composition
imagePainter = QPainter(image)
c.renderPage(imagePainter, 0)
imagePainter.end()
outName = os.path.join(self.workingFolder, outName + '.png')
image.save(outName, "png")
return outName
class Map():
"""A class for creating a map."""
def __init__(self, iface):
"""Constructor for the Map class.
:param iface: Reference to the QGIS iface object.
:type iface: QgsAppInterface
"""
LOGGER.debug('InaSAFE Map class initialised')
self.iface = iface
self.layer = iface.activeLayer()
self.keyword_io = KeywordIO()
self.printer = None
self.composition = None
self.extent = iface.mapCanvas().extent()
self.safe_logo = ':/plugins/inasafe/inasafe-logo-url.svg'
self.north_arrow = ':/plugins/inasafe/simple_north_arrow.png'
self.org_logo = ':/plugins/inasafe/supporters.png'
self.template = ':/plugins/inasafe/inasafe-portrait-a4.qpt'
self.disclaimer = disclaimer()
self.page_width = 0 # width in mm
self.page_height = 0 # height in mm
self.page_dpi = 300.0
self.show_frames = False # intended for debugging use only
@staticmethod
def tr(string):
"""We implement this since we do not inherit QObject.
:param string: String for translation.
:type string: QString, str
:returns: Translated version of theString.
:rtype: QString
"""
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
return QtCore.QCoreApplication.translate('Map', string)
def set_impact_layer(self, layer):
"""Set the layer that will be used for stats, legend and reporting.
:param layer: Layer that will be used for stats, legend and reporting.
:type layer: QgsMapLayer, QgsRasterLayer, QgsVectorLayer
"""
self.layer = layer
def set_north_arrow_image(self, logo_path):
"""Set image that will be used as organisation logo in reports.
:param logo_path: Path to image file
:type logo_path: str
"""
self.north_arrow = logo_path
def set_organisation_logo(self, logo):
"""Set image that will be used as organisation logo in reports.
:param logo: Path to image file
:type logo: str
"""
self.org_logo = logo
def set_disclaimer(self, text):
"""Set text that will be used as disclaimer in reports.
:param text: Disclaimer text
:type text: str
"""
self.disclaimer = text
def set_template(self, template):
"""Set template that will be used for report generation.
:param template: Path to composer template
:type template: str
"""
self.template = template
def set_extent(self, extent):
"""Set extent or the report map
:param extent: Extent of the report map
:type extent: QgsRectangle
"""
self.extent = extent
def setup_composition(self):
"""Set up the composition ready for drawing elements onto it."""
LOGGER.debug('InaSAFE Map setupComposition called')
canvas = self.iface.mapCanvas()
renderer = canvas.mapRenderer()
self.composition = QgsComposition(renderer)
self.composition.setPlotStyle(QgsComposition.Preview) # or preview
self.composition.setPrintResolution(self.page_dpi)
self.composition.setPrintAsRaster(True)
def make_pdf(self, filename):
"""Generate the printout for our final map.
:param filename: Path on the file system to which the pdf should be
saved. If None, a generated file name will be used.
:type filename: str
:returns: File name of the output file (equivalent to filename if
provided).
:rtype: str
"""
LOGGER.debug('InaSAFE Map printToPdf called')
if filename is None:
map_pdf_path = unique_filename(
prefix='report', suffix='.pdf', dir=temp_dir())
else:
# We need to cast to python string in case we receive a QString
map_pdf_path = str(filename)
self.load_template()
self.composition.exportAsPDF(map_pdf_path)
return map_pdf_path
def map_title(self):
"""Get the map title from the layer keywords if possible.
:returns: None on error, otherwise the title.
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapTitle called')
try:
title = self.keyword_io.read_keywords(self.layer, 'map_title')
return title
except KeywordNotFoundError:
return None
except Exception:
return None
def map_legend_attributes(self):
"""Get the map legend attribute from the layer keywords if possible.
:returns: None on error, otherwise the attributes (notes and units).
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapLegendAttributes called')
legend_attribute_list = [
'legend_notes',
'legend_units',
'legend_title']
legend_attribute_dict = {}
for myLegendAttribute in legend_attribute_list:
# noinspection PyBroadException
try:
legend_attribute_dict[myLegendAttribute] = \
self.keyword_io.read_keywords(
self.layer, myLegendAttribute)
except KeywordNotFoundError:
pass
except Exception:
pass
return legend_attribute_dict
def load_template(self):
"""Load a QgsComposer map from a template.
"""
self.setup_composition()
template_file = QtCore.QFile(self.template)
template_file.open(QtCore.QIODevice.ReadOnly | QtCore.QIODevice.Text)
template_content = template_file.readAll()
template_file.close()
document = QtXml.QDomDocument()
document.setContent(template_content)
# get information for substitutions
# date, time and plugin version
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
if date_time is None:
date = ''
time = ''
else:
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
title = self.map_title()
if not title:
title = ''
substitution_map = {
'impact-title': title,
'date': date,
'time': time,
'safe-version': version,
'disclaimer': self.disclaimer
}
LOGGER.debug(substitution_map)
load_ok = self.composition.loadFromTemplate(
document, substitution_map)
if not load_ok:
raise ReportCreationError(
self.tr('Error loading template %s') %
self.template)
self.page_width = self.composition.paperWidth()
self.page_height = self.composition.paperHeight()
# set InaSAFE logo
image = self.composition.getComposerItemById('safe-logo')
if image is not None:
image.setPictureFile(self.safe_logo)
else:
raise ReportCreationError(self.tr(
'Image "safe-logo" could not be found'))
# set north arrow
image = self.composition.getComposerItemById('north-arrow')
if image is not None:
image.setPictureFile(self.north_arrow)
else:
raise ReportCreationError(self.tr(
'Image "north arrow" could not be found'))
# set organisation logo
image = self.composition.getComposerItemById('organisation-logo')
if image is not None:
image.setPictureFile(self.org_logo)
else:
raise ReportCreationError(self.tr(
'Image "organisation-logo" could not be found'))
# set impact report table
table = self.composition.getComposerItemById('impact-report')
if table is not None:
text = self.keyword_io.read_keywords(self.layer, 'impact_summary')
if text is None:
text = ''
table.setText(text)
table.setHtmlState(1)
else:
LOGGER.debug('"impact-report" element not found.')
# Get the main map canvas on the composition and set
# its extents to the event.
composer_map = self.composition.getComposerItemById('impact-map')
if composer_map is not None:
# Recenter the composer map on the center of the extent
# Note that since the composer map is square and the canvas may be
# arbitrarily shaped, we center based on the longest edge
canvas_extent = self.extent
width = canvas_extent.width()
height = canvas_extent.height()
longest_width = width
if width < height:
longest_width = height
half_length = longest_width / 2
center = canvas_extent.center()
min_x = center.x() - half_length
max_x = center.x() + half_length
min_y = center.y() - half_length
max_y = center.y() + half_length
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
composer_map.setNewExtent(square_extent)
# calculate intervals for grid
split_count = 5
x_interval = square_extent.width() / split_count
composer_map.setGridIntervalX(x_interval)
y_interval = square_extent.height() / split_count
composer_map.setGridIntervalY(y_interval)
else:
raise ReportCreationError(self.tr(
'Map "impact-map" could not be found'))
legend = self.composition.getComposerItemById('impact-legend')
legend_attributes = self.map_legend_attributes()
LOGGER.debug(legend_attributes)
#legend_notes = mapLegendAttributes.get('legend_notes', None)
#legend_units = mapLegendAttributes.get('legend_units', None)
legend_title = legend_attributes.get('legend_title', None)
symbol_count = 1
if self.layer.type() == QgsMapLayer.VectorLayer:
renderer = self.layer.rendererV2()
if renderer.type() in ['', '']:
symbol_count = len(self.layer.legendSymbologyItems())
else:
renderer = self.layer.renderer()
if renderer.type() in ['']:
symbol_count = len(self.layer.legendSymbologyItems())
if symbol_count <= 5:
legend.setColumnCount(1)
else:
legend.setColumnCount(symbol_count / 5 + 1)
if legend_title is None:
legend_title = ""
legend.setTitle(legend_title)
legend.updateLegend()
# remove from legend all layers, except impact one
model = legend.model()
if model.rowCount() > 0 and model.columnCount() > 0:
impact_item = model.findItems(self.layer.name())[0]
row = impact_item.index().row()
model.removeRows(row + 1, model.rowCount() - row)
if row > 0:
model.removeRows(0, row)
class TestComposerBase(TestQgsPalLabeling):
layer = None
""":type: QgsVectorLayer"""
@classmethod
def setUpClass(cls):
if not cls._BaseSetup:
TestQgsPalLabeling.setUpClass()
# the blue background (set via layer style) to match renderchecker's
TestQgsPalLabeling.loadFeatureLayer('background', True)
cls._TestKind = 0 # OutputKind.(Img|Svg|Pdf)
@classmethod
def tearDownClass(cls):
"""Run after all tests"""
TestQgsPalLabeling.tearDownClass()
cls.removeMapLayer(cls.layer)
cls.layer = None
def setUp(self):
"""Run before each test."""
super(TestComposerBase, self).setUp()
self._TestImage = ''
# ensure per test map settings stay encapsulated
self._TestMapSettings = self.cloneMapSettings(self._MapSettings)
self._Mismatch = 0
self._ColorTol = 0
self._Mismatches.clear()
self._ColorTols.clear()
def _set_up_composition(self, width, height, dpi):
# set up composition and add map
self._c = QgsComposition(QgsProject.instance())
""":type: QgsComposition"""
# self._c.setUseAdvancedEffects(False)
self._c.setPrintResolution(dpi)
# 600 x 400 px = 211.67 x 141.11 mm @ 72 dpi
paperw = width * 25.4 / dpi
paperh = height * 25.4 / dpi
self._c.setPaperSize(paperw, paperh)
# NOTE: do not use QgsComposerMap(self._c, 0, 0, paperw, paperh) since
# it only takes integers as parameters and the composition will grow
# larger based upon union of item scene rectangles and a slight buffer
# see end of QgsComposition::compositionBounds()
# add map as small graphics item first, then set its scene QRectF later
self._cmap = QgsComposerMap(self._c, 10, 10, 10, 10)
""":type: QgsComposerMap"""
self._cmap.setPreviewMode(QgsComposerMap.Render)
self._cmap.setFrameEnabled(False)
self._cmap.setLayers(self._TestMapSettings.layers())
self._c.addComposerMap(self._cmap)
# now expand map to fill page and set its extent
self._cmap.setSceneRect(QRectF(0, 0, paperw, paperw))
self._cmap.setNewExtent(self.aoiExtent())
# self._cmap.updateCachedImage()
self._c.setPlotStyle(QgsComposition.Print)
# noinspection PyUnusedLocal
def _get_composer_image(self, width, height, dpi):
image = QImage(QSize(width, height),
self._TestMapSettings.outputImageFormat())
image.fill(QColor(152, 219, 249).rgb())
image.setDotsPerMeterX(dpi / 25.4 * 1000)
image.setDotsPerMeterY(dpi / 25.4 * 1000)
p = QPainter(image)
p.setRenderHint(
QPainter.Antialiasing,
self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing))
self._c.renderPage(p, 0)
p.end()
# image = self._c.printPageAsRaster(0)
# """:type: QImage"""
if image.isNull():
return False, ''
filepath = getTempfilePath('png')
res = image.save(filepath, 'png')
if not res:
os.unlink(filepath)
filepath = ''
return res, filepath
def _get_composer_svg_image(self, width, height, dpi):
# from qgscomposer.cpp, QgsComposer::on_mActionExportAsSVG_triggered,
# near end of function
svgpath = getTempfilePath('svg')
temp_size = os.path.getsize(svgpath)
svg_g = QSvgGenerator()
# noinspection PyArgumentList
svg_g.setTitle(QgsProject.instance().title())
svg_g.setFileName(svgpath)
svg_g.setSize(QSize(width, height))
svg_g.setViewBox(QRect(0, 0, width, height))
svg_g.setResolution(dpi)
sp = QPainter(svg_g)
self._c.renderPage(sp, 0)
sp.end()
if temp_size == os.path.getsize(svgpath):
return False, ''
image = QImage(width, height,
self._TestMapSettings.outputImageFormat())
image.fill(QColor(152, 219, 249).rgb())
image.setDotsPerMeterX(dpi / 25.4 * 1000)
image.setDotsPerMeterY(dpi / 25.4 * 1000)
svgr = QSvgRenderer(svgpath)
p = QPainter(image)
p.setRenderHint(
QPainter.Antialiasing,
self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing))
p.setRenderHint(QPainter.TextAntialiasing)
svgr.render(p)
p.end()
filepath = getTempfilePath('png')
res = image.save(filepath, 'png')
if not res:
os.unlink(filepath)
filepath = ''
# TODO: remove .svg file as well?
return res, filepath
def _get_composer_pdf_image(self, width, height, dpi):
pdfpath = getTempfilePath('pdf')
temp_size = os.path.getsize(pdfpath)
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(pdfpath)
p.setPaperSize(QSizeF(self._c.paperWidth(), self._c.paperHeight()),
QPrinter.Millimeter)
p.setFullPage(True)
p.setColorMode(QPrinter.Color)
p.setResolution(self._c.printResolution())
pdf_p = QPainter(p)
# page_mm = p.pageRect(QPrinter.Millimeter)
# page_px = p.pageRect(QPrinter.DevicePixel)
# self._c.render(pdf_p, page_px, page_mm)
self._c.renderPage(pdf_p, 0)
pdf_p.end()
if temp_size == os.path.getsize(pdfpath):
return False, ''
filepath = getTempfilePath('png')
# Poppler (pdftocairo or pdftoppm):
# PDFUTIL -png -singlefile -r 72 -x 0 -y 0 -W 420 -H 280 in.pdf pngbase
# muPDF (mudraw):
# PDFUTIL -c rgb[a] -r 72 -w 420 -h 280 -o out.png in.pdf
if PDFUTIL.strip().endswith('pdftocairo'):
filebase = os.path.join(
os.path.dirname(filepath),
os.path.splitext(os.path.basename(filepath))[0])
call = [
PDFUTIL, '-png', '-singlefile', '-r',
str(dpi), '-x', '0', '-y', '0', '-W',
str(width), '-H',
str(height), pdfpath, filebase
]
elif PDFUTIL.strip().endswith('mudraw'):
call = [
PDFUTIL,
'-c',
'rgba',
'-r',
str(dpi),
'-w',
str(width),
'-h',
str(height),
# '-b', '8',
'-o',
filepath,
pdfpath
]
else:
return False, ''
qDebug("_get_composer_pdf_image call: {0}".format(' '.join(call)))
res = False
try:
subprocess.check_call(call)
res = True
except subprocess.CalledProcessError as e:
qDebug("_get_composer_pdf_image failed!\n"
"cmd: {0}\n"
"returncode: {1}\n"
"message: {2}".format(e.cmd, e.returncode, e.message))
if not res:
os.unlink(filepath)
filepath = ''
return res, filepath
def get_composer_output(self, kind):
ms = self._TestMapSettings
osize = ms.outputSize()
width, height, dpi = osize.width(), osize.height(), ms.outputDpi()
self._set_up_composition(width, height, dpi)
if kind == OutputKind.Svg:
return self._get_composer_svg_image(width, height, dpi)
elif kind == OutputKind.Pdf:
return self._get_composer_pdf_image(width, height, dpi)
else: # OutputKind.Img
return self._get_composer_image(width, height, dpi)
# noinspection PyUnusedLocal
def checkTest(self, **kwargs):
self.lyr.writeToLayer(self.layer)
ms = self._MapSettings # class settings
settings_type = 'Class'
if self._TestMapSettings is not None:
ms = self._TestMapSettings # per test settings
settings_type = 'Test'
if 'PAL_VERBOSE' in os.environ:
qDebug('MapSettings type: {0}'.format(settings_type))
qDebug(mapSettingsString(ms))
res_m, self._TestImage = self.get_composer_output(self._TestKind)
self.assertTrue(res_m, 'Failed to retrieve/save output from composer')
self.saveControlImage(self._TestImage)
mismatch = 0
if 'PAL_NO_MISMATCH' not in os.environ:
# some mismatch expected
mismatch = self._Mismatch if self._Mismatch else 20
if self._TestGroup in self._Mismatches:
mismatch = self._Mismatches[self._TestGroup]
colortol = 0
if 'PAL_NO_COLORTOL' not in os.environ:
colortol = self._ColorTol if self._ColorTol else 0
if self._TestGroup in self._ColorTols:
colortol = self._ColorTols[self._TestGroup]
self.assertTrue(*self.renderCheck(
mismatch=mismatch, colortol=colortol, imgpath=self._TestImage))
class TestComposerBase(TestQgsPalLabeling):
layer = None
""":type: QgsVectorLayer"""
@classmethod
def setUpClass(cls):
if not cls._BaseSetup:
TestQgsPalLabeling.setUpClass()
# the blue background (set via layer style) to match renderchecker's
TestQgsPalLabeling.loadFeatureLayer('background', True)
cls._TestKind = 0 # OutputKind.(Img|Svg|Pdf)
@classmethod
def tearDownClass(cls):
"""Run after all tests"""
TestQgsPalLabeling.tearDownClass()
cls.removeMapLayer(cls.layer)
cls.layer = None
def setUp(self):
"""Run before each test."""
super(TestComposerBase, self).setUp()
self._TestImage = ''
# ensure per test map settings stay encapsulated
self._TestMapSettings = self.cloneMapSettings(self._MapSettings)
self._Mismatch = 0
self._ColorTol = 0
self._Mismatches.clear()
self._ColorTols.clear()
def _set_up_composition(self, width, height, dpi):
# set up composition and add map
self._c = QgsComposition(self._TestMapSettings, QgsProject.instance())
""":type: QgsComposition"""
# self._c.setUseAdvancedEffects(False)
self._c.setPrintResolution(dpi)
# 600 x 400 px = 211.67 x 141.11 mm @ 72 dpi
paperw = width * 25.4 / dpi
paperh = height * 25.4 / dpi
self._c.setPaperSize(paperw, paperh)
# NOTE: do not use QgsComposerMap(self._c, 0, 0, paperw, paperh) since
# it only takes integers as parameters and the composition will grow
# larger based upon union of item scene rectangles and a slight buffer
# see end of QgsComposition::compositionBounds()
# add map as small graphics item first, then set its scene QRectF later
self._cmap = QgsComposerMap(self._c, 10, 10, 10, 10)
""":type: QgsComposerMap"""
self._cmap.setPreviewMode(QgsComposerMap.Render)
self._cmap.setFrameEnabled(False)
self._c.addComposerMap(self._cmap)
# now expand map to fill page and set its extent
self._cmap.setSceneRect(QRectF(0, 0, paperw, paperw))
self._cmap.setNewExtent(self.aoiExtent())
# self._cmap.updateCachedImage()
self._c.setPlotStyle(QgsComposition.Print)
# noinspection PyUnusedLocal
def _get_composer_image(self, width, height, dpi):
image = QImage(QSize(width, height),
self._TestMapSettings.outputImageFormat())
image.fill(QColor(152, 219, 249).rgb())
image.setDotsPerMeterX(dpi / 25.4 * 1000)
image.setDotsPerMeterY(dpi / 25.4 * 1000)
p = QPainter(image)
p.setRenderHint(
QPainter.Antialiasing,
self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing)
)
self._c.renderPage(p, 0)
p.end()
# image = self._c.printPageAsRaster(0)
# """:type: QImage"""
if image.isNull():
return False, ''
filepath = getTempfilePath('png')
res = image.save(filepath, 'png')
if not res:
os.unlink(filepath)
filepath = ''
return res, filepath
def _get_composer_svg_image(self, width, height, dpi):
# from qgscomposer.cpp, QgsComposer::on_mActionExportAsSVG_triggered,
# near end of function
svgpath = getTempfilePath('svg')
temp_size = os.path.getsize(svgpath)
svg_g = QSvgGenerator()
# noinspection PyArgumentList
svg_g.setTitle(QgsProject.instance().title())
svg_g.setFileName(svgpath)
svg_g.setSize(QSize(width, height))
svg_g.setViewBox(QRect(0, 0, width, height))
svg_g.setResolution(dpi)
sp = QPainter(svg_g)
self._c.renderPage(sp, 0)
sp.end()
if temp_size == os.path.getsize(svgpath):
return False, ''
image = QImage(width, height, self._TestMapSettings.outputImageFormat())
image.fill(QColor(152, 219, 249).rgb())
image.setDotsPerMeterX(dpi / 25.4 * 1000)
image.setDotsPerMeterY(dpi / 25.4 * 1000)
svgr = QSvgRenderer(svgpath)
p = QPainter(image)
p.setRenderHint(
QPainter.Antialiasing,
self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing)
)
p.setRenderHint(QPainter.TextAntialiasing)
svgr.render(p)
p.end()
filepath = getTempfilePath('png')
res = image.save(filepath, 'png')
if not res:
os.unlink(filepath)
filepath = ''
# TODO: remove .svg file as well?
return res, filepath
def _get_composer_pdf_image(self, width, height, dpi):
pdfpath = getTempfilePath('pdf')
temp_size = os.path.getsize(pdfpath)
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(pdfpath)
p.setPaperSize(QSizeF(self._c.paperWidth(), self._c.paperHeight()),
QPrinter.Millimeter)
p.setFullPage(True)
p.setColorMode(QPrinter.Color)
p.setResolution(self._c.printResolution())
pdf_p = QPainter(p)
# page_mm = p.pageRect(QPrinter.Millimeter)
# page_px = p.pageRect(QPrinter.DevicePixel)
# self._c.render(pdf_p, page_px, page_mm)
self._c.renderPage(pdf_p, 0)
pdf_p.end()
if temp_size == os.path.getsize(pdfpath):
return False, ''
filepath = getTempfilePath('png')
# Poppler (pdftocairo or pdftoppm):
# PDFUTIL -png -singlefile -r 72 -x 0 -y 0 -W 420 -H 280 in.pdf pngbase
# muPDF (mudraw):
# PDFUTIL -c rgb[a] -r 72 -w 420 -h 280 -o out.png in.pdf
if PDFUTIL.strip().endswith('pdftocairo'):
filebase = os.path.join(
os.path.dirname(filepath),
os.path.splitext(os.path.basename(filepath))[0]
)
call = [
PDFUTIL, '-png', '-singlefile', '-r', str(dpi),
'-x', '0', '-y', '0', '-W', str(width), '-H', str(height),
pdfpath, filebase
]
elif PDFUTIL.strip().endswith('mudraw'):
call = [
PDFUTIL, '-c', 'rgba',
'-r', str(dpi), '-w', str(width), '-h', str(height),
# '-b', '8',
'-o', filepath, pdfpath
]
else:
return False, ''
qDebug("_get_composer_pdf_image call: {0}".format(' '.join(call)))
res = False
try:
subprocess.check_call(call)
res = True
except subprocess.CalledProcessError as e:
qDebug("_get_composer_pdf_image failed!\n"
"cmd: {0}\n"
"returncode: {1}\n"
"message: {2}".format(e.cmd, e.returncode, e.message))
if not res:
os.unlink(filepath)
filepath = ''
return res, filepath
def get_composer_output(self, kind):
ms = self._TestMapSettings
osize = ms.outputSize()
width, height, dpi = osize.width(), osize.height(), ms.outputDpi()
self._set_up_composition(width, height, dpi)
if kind == OutputKind.Svg:
return self._get_composer_svg_image(width, height, dpi)
elif kind == OutputKind.Pdf:
return self._get_composer_pdf_image(width, height, dpi)
else: # OutputKind.Img
return self._get_composer_image(width, height, dpi)
# noinspection PyUnusedLocal
def checkTest(self, **kwargs):
self.lyr.writeToLayer(self.layer)
ms = self._MapSettings # class settings
settings_type = 'Class'
if self._TestMapSettings is not None:
ms = self._TestMapSettings # per test settings
settings_type = 'Test'
if 'PAL_VERBOSE' in os.environ:
qDebug('MapSettings type: {0}'.format(settings_type))
qDebug(mapSettingsString(ms))
res_m, self._TestImage = self.get_composer_output(self._TestKind)
self.assertTrue(res_m, 'Failed to retrieve/save output from composer')
self.saveControlImage(self._TestImage)
mismatch = 0
if 'PAL_NO_MISMATCH' not in os.environ:
# some mismatch expected
mismatch = self._Mismatch if self._Mismatch else 20
if self._TestGroup in self._Mismatches:
mismatch = self._Mismatches[self._TestGroup]
colortol = 0
if 'PAL_NO_COLORTOL' not in os.environ:
colortol = self._ColorTol if self._ColorTol else 0
if self._TestGroup in self._ColorTols:
colortol = self._ColorTols[self._TestGroup]
self.assertTrue(*self.renderCheck(mismatch=mismatch,
colortol=colortol,
imgpath=self._TestImage))
class Map():
"""A class for creating a map."""
def __init__(self, iface):
"""Constructor for the Map class.
:param iface: Reference to the QGIS iface object.
:type iface: QgsAppInterface
"""
LOGGER.debug('InaSAFE Map class initialised')
self.iface = iface
self.layer = iface.activeLayer()
self.keyword_io = KeywordIO()
self.printer = None
self.composition = None
self.extent = iface.mapCanvas().extent()
self.safe_logo = ':/plugins/inasafe/inasafe-logo-url.svg'
self.north_arrow = ':/plugins/inasafe/simple_north_arrow.png'
self.org_logo = ':/plugins/inasafe/supporters.png'
self.template = ':/plugins/inasafe/inasafe-portrait-a4.qpt'
self.disclaimer = disclaimer()
self.page_width = 0 # width in mm
self.page_height = 0 # height in mm
self.page_dpi = 300.0
self.show_frames = False # intended for debugging use only
@staticmethod
def tr(string):
"""We implement this since we do not inherit QObject.
:param string: String for translation.
:type string: QString, str
:returns: Translated version of theString.
:rtype: QString
"""
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
return QtCore.QCoreApplication.translate('Map', string)
def set_impact_layer(self, layer):
"""Set the layer that will be used for stats, legend and reporting.
:param layer: Layer that will be used for stats, legend and reporting.
:type layer: QgsMapLayer, QgsRasterLayer, QgsVectorLayer
"""
self.layer = layer
def set_north_arrow_image(self, logo_path):
"""Set image that will be used as organisation logo in reports.
:param logo_path: Path to image file
:type logo_path: str
"""
self.north_arrow = logo_path
def set_organisation_logo(self, logo):
"""Set image that will be used as organisation logo in reports.
:param logo: Path to image file
:type logo: str
"""
self.org_logo = logo
def set_disclaimer(self, text):
"""Set text that will be used as disclaimer in reports.
:param text: Disclaimer text
:type text: str
"""
self.disclaimer = text
def set_template(self, template):
"""Set template that will be used for report generation.
:param template: Path to composer template
:type template: str
"""
self.template = template
def set_extent(self, extent):
"""Set extent or the report map
:param extent: Extent of the report map
:type extent: QgsRectangle
"""
self.extent = extent
def setup_composition(self):
"""Set up the composition ready for drawing elements onto it."""
LOGGER.debug('InaSAFE Map setupComposition called')
canvas = self.iface.mapCanvas()
renderer = canvas.mapRenderer()
self.composition = QgsComposition(renderer)
self.composition.setPlotStyle(QgsComposition.Preview) # or preview
self.composition.setPrintResolution(self.page_dpi)
self.composition.setPrintAsRaster(True)
def make_pdf(self, filename):
"""Generate the printout for our final map.
:param filename: Path on the file system to which the pdf should be
saved. If None, a generated file name will be used.
:type filename: str
:returns: File name of the output file (equivalent to filename if
provided).
:rtype: str
"""
LOGGER.debug('InaSAFE Map printToPdf called')
if filename is None:
map_pdf_path = unique_filename(prefix='report',
suffix='.pdf',
dir=temp_dir())
else:
# We need to cast to python string in case we receive a QString
map_pdf_path = str(filename)
self.load_template()
self.composition.exportAsPDF(map_pdf_path)
return map_pdf_path
def map_title(self):
"""Get the map title from the layer keywords if possible.
:returns: None on error, otherwise the title.
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapTitle called')
try:
title = self.keyword_io.read_keywords(self.layer, 'map_title')
return title
except KeywordNotFoundError:
return None
except Exception:
return None
def map_legend_attributes(self):
"""Get the map legend attribute from the layer keywords if possible.
:returns: None on error, otherwise the attributes (notes and units).
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapLegendAttributes called')
legend_attribute_list = [
'legend_notes', 'legend_units', 'legend_title'
]
legend_attribute_dict = {}
for myLegendAttribute in legend_attribute_list:
# noinspection PyBroadException
try:
legend_attribute_dict[myLegendAttribute] = \
self.keyword_io.read_keywords(
self.layer, myLegendAttribute)
except KeywordNotFoundError:
pass
except Exception:
pass
return legend_attribute_dict
def load_template(self):
"""Load a QgsComposer map from a template.
"""
self.setup_composition()
template_file = QtCore.QFile(self.template)
template_file.open(QtCore.QIODevice.ReadOnly | QtCore.QIODevice.Text)
template_content = template_file.readAll()
template_file.close()
document = QtXml.QDomDocument()
document.setContent(template_content)
# get information for substitutions
# date, time and plugin version
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
if date_time is None:
date = ''
time = ''
else:
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
title = self.map_title()
if not title:
title = ''
substitution_map = {
'impact-title': title,
'date': date,
'time': time,
'safe-version': version,
'disclaimer': self.disclaimer
}
LOGGER.debug(substitution_map)
load_ok = self.composition.loadFromTemplate(document, substitution_map)
if not load_ok:
raise ReportCreationError(
self.tr('Error loading template %s') % self.template)
self.page_width = self.composition.paperWidth()
self.page_height = self.composition.paperHeight()
# set InaSAFE logo
image = self.composition.getComposerItemById('safe-logo')
if image is not None:
image.setPictureFile(self.safe_logo)
else:
raise ReportCreationError(
self.tr('Image "safe-logo" could not be found'))
# set north arrow
image = self.composition.getComposerItemById('north-arrow')
if image is not None:
image.setPictureFile(self.north_arrow)
else:
raise ReportCreationError(
self.tr('Image "north arrow" could not be found'))
# set organisation logo
image = self.composition.getComposerItemById('organisation-logo')
if image is not None:
image.setPictureFile(self.org_logo)
else:
raise ReportCreationError(
self.tr('Image "organisation-logo" could not be found'))
# set impact report table
table = self.composition.getComposerItemById('impact-report')
if table is not None:
text = self.keyword_io.read_keywords(self.layer, 'impact_summary')
if text is None:
text = ''
table.setText(text)
table.setHtmlState(1)
else:
LOGGER.debug('"impact-report" element not found.')
# Get the main map canvas on the composition and set
# its extents to the event.
composer_map = self.composition.getComposerItemById('impact-map')
if composer_map is not None:
# Recenter the composer map on the center of the extent
# Note that since the composer map is square and the canvas may be
# arbitrarily shaped, we center based on the longest edge
canvas_extent = self.extent
width = canvas_extent.width()
height = canvas_extent.height()
longest_width = width
if width < height:
longest_width = height
half_length = longest_width / 2
center = canvas_extent.center()
min_x = center.x() - half_length
max_x = center.x() + half_length
min_y = center.y() - half_length
max_y = center.y() + half_length
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
composer_map.setNewExtent(square_extent)
# calculate intervals for grid
split_count = 5
x_interval = square_extent.width() / split_count
composer_map.setGridIntervalX(x_interval)
y_interval = square_extent.height() / split_count
composer_map.setGridIntervalY(y_interval)
else:
raise ReportCreationError(
self.tr('Map "impact-map" could not be found'))
legend = self.composition.getComposerItemById('impact-legend')
legend_attributes = self.map_legend_attributes()
LOGGER.debug(legend_attributes)
#legend_notes = mapLegendAttributes.get('legend_notes', None)
#legend_units = mapLegendAttributes.get('legend_units', None)
legend_title = legend_attributes.get('legend_title', None)
symbol_count = 1
if self.layer.type() == QgsMapLayer.VectorLayer:
renderer = self.layer.rendererV2()
if renderer.type() in ['', '']:
symbol_count = len(self.layer.legendSymbologyItems())
else:
renderer = self.layer.renderer()
if renderer.type() in ['']:
symbol_count = len(self.layer.legendSymbologyItems())
if symbol_count <= 5:
legend.setColumnCount(1)
else:
legend.setColumnCount(symbol_count / 5 + 1)
if legend_title is None:
legend_title = ""
legend.setTitle(legend_title)
legend.updateLegend()
# remove from legend all layers, except impact one
model = legend.model()
if model.rowCount() > 0 and model.columnCount() > 0:
impact_item = model.findItems(self.layer.name())[0]
row = impact_item.index().row()
model.removeRows(row + 1, model.rowCount() - row)
if row > 0:
model.removeRows(0, row)
def export_all_features(self):
pdf_painter = None
"""Export map to pdf atlas style (one page per feature)"""
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'exporting map', DLG_CAPTION)
try:
result = self.__delete_pdf()
if not result is None:
return result
ids = []
exp = QgsExpression(self.feature_filter)
if exp.hasParserError():
raise Exception(exp.parserErrorString())
exp.prepare(self.coverage_layer.pendingFields())
for feature in self.coverage_layer.getFeatures():
value = exp.evaluate(feature)
if exp.hasEvalError():
raise ValueError(exp.evalErrorString())
if bool(value):
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'export map, feature id:{0}'.format(feature.id()), DLG_CAPTION)
ids.append(feature.id())
self.coverage_layer.select(ids)
bbox = self.coverage_layer.boundingBoxOfSelected()
self.canvas.zoomToSelected(self.coverage_layer)
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'bbox:{0}'.format(bbox.toString()), DLG_CAPTION)
#self.map_renderer.setExtent(bbox)
#self.map_renderer.updateScale()
#read plotlayout
composition = QgsComposition(self.map_renderer)
self.composition = composition
composition.setPlotStyle(QgsComposition.Print)
error, xml_doc = self.__read_template()
if not error is None:
return error
if composition.loadFromTemplate(xml_doc) is False:
return u'Konnte Template nicht laden!\n{0}'.format(self.template_qpt)
#read textinfo layout
self.comp_textinfo = QgsComposition(self.map_renderer)
self.comp_textinfo.setPlotStyle(QgsComposition.Print)
error, xml_doc = self.__read_template(True)
if not error is None:
return error
if self.comp_textinfo.loadFromTemplate(xml_doc) is False:
return u'Konnte Template nicht laden!\n{0}'.format(self.settings.textinfo_layout())
new_ext = bbox
if QGis.QGIS_VERSION_INT > 20200:
compmaps = self.__get_items(QgsComposerMap)
if len(compmaps) < 1:
return u'Kein Kartenfenster im Layout vorhanden!'
compmap = compmaps[0]
else:
if len(composition.composerMapItems()) < 1:
return u'Kein Kartenfenster im Layout vorhanden!'
compmap = composition.composerMapItems()[0]
self.composermap = compmap
#self.composermap.setPreviewMode(QgsComposerMap.Render)
#self.composermap.setPreviewMode(QgsComposerMap.Rectangle)
#taken from QgsComposerMap::setNewAtlasFeatureExtent (not yet available in QGIS 2.0)
#http://www.qgis.org/api/qgscomposermap_8cpp_source.html#l00610
old_ratio = compmap.rect().width() / compmap.rect().height()
new_ratio = new_ext.width() / new_ext.height()
if old_ratio < new_ratio:
new_height = new_ext.width() / old_ratio
delta_height = new_height - new_ext.height()
new_ext.setYMinimum( bbox.yMinimum() - delta_height / 2)
new_ext.setYMaximum(bbox.yMaximum() + delta_height / 2)
else:
new_width = old_ratio * new_ext.height()
delta_width = new_width - new_ext.width()
new_ext.setXMinimum(bbox.xMinimum() - delta_width / 2)
new_ext.setXMaximum(bbox.xMaximum() + delta_width / 2)
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'bbox old:{0}'.format(compmap.extent().toString()), DLG_CAPTION)
compmap.setNewExtent(new_ext)
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'bbox new:{0}'.format(compmap.extent().toString()), DLG_CAPTION)
#round up to next 1000
compmap.setNewScale(math.ceil((compmap.scale()/1000.0)) * 1000.0)
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'bbox new (after scale):{0}'.format(compmap.extent().toString()), DLG_CAPTION)
#add ORTHO after new extent -> performance
if not self.ortho is None:
self.ortho_lyr = self.__add_raster_layer(self.ortho, self.lyrname_ortho)
self.__reorder_layers()
self.comp_leg = self.__get_items(QgsComposerLegend)
self.comp_lbl = self.__get_items(QgsComposerLabel)
self.__update_composer_items(self.settings.dkm_gemeinde(self.gem_name)['lyrnamegstk'])
if VRP_DEBUG is True:
QgsMessageLog.logMessage(u'paperWidth:{0} paperHeight:{1}'.format(composition.paperWidth(), composition.paperHeight()), DLG_CAPTION)
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(self.pdf_map)
printer.setPaperSize(QSizeF(composition.paperWidth(), composition.paperHeight()), QPrinter.Millimeter)
printer.setFullPage(True)
printer.setColorMode(QPrinter.Color)
printer.setResolution(composition.printResolution())
pdf_painter = QPainter(printer)
paper_rect_pixel = printer.pageRect(QPrinter.DevicePixel)
paper_rect_mm = printer.pageRect(QPrinter.Millimeter)
QgsPaintEngineHack.fixEngineFlags(printer.paintEngine())
#DKM only
if len(self.themen) < 1:
composition.render(pdf_painter, paper_rect_pixel, paper_rect_mm)
else:
self.statistics = OrderedDict()
try:
pass
#lyr = QgsVectorLayer('/home/bergw/VoGIS-Raumplanung-Daten/Geodaten/Raumplanung/Flaechenwidmung/Dornbirn/Flaechenwidmungsplan/fwp_flaeche.shp', 'flaeiw', 'ogr')
#lyr.loadNamedStyle('/home/bergw/VoGIS-Raumplanung-Daten/Geodaten/Raumplanung/Flaechenwidmung/Vorarlberg/Flaechenwidmungsplan/fwp_flaeche.qml')
#QgsMapLayerRegistry.instance().addMapLayer(lyr)
except:
QgsMessageLog.logMessage('new lyr:{0}'.format(sys.exc_info()[0]), DLG_CAPTION)
#QgsMapLayerRegistry.instance().addMapLayer(lyr)
cntr = 0
for thema, sub_themen in self.themen.iteritems():
if VRP_DEBUG is True: QgsMessageLog.logMessage('drucke Thema:{0}'.format(thema.name), DLG_CAPTION)
if sub_themen is None:
layers = self.__add_layers(thema)
self.__calculate_statistics(thema, thema, layers)
#no qml -> not visible -> means no map
if self.__at_least_one_visible(layers) is True:
if cntr > 0:
printer.newPage()
self.__reorder_layers()
self.__update_composer_items(thema.name, layers=layers)
composition.renderPage(pdf_painter, 0)
QgsMapLayerRegistry.instance().removeMapLayers([lyr.id() for lyr in layers])
cntr += 1
else:
QgsMapLayerRegistry.instance().removeMapLayers([lyr.id() for lyr in layers])
if not sub_themen is None:
for sub_thema in sub_themen:
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'drucke SubThema:{0}'.format(sub_thema.name), DLG_CAPTION)
layers = self.__add_layers(sub_thema)
self.__calculate_statistics(thema, sub_thema, layers)
#no qml -> not visible -> means no map
if self.__at_least_one_visible(layers) is True:
if cntr > 0:
printer.newPage()
self.__reorder_layers()
self.__update_composer_items(thema.name, subthema=sub_thema.name, layers=layers)
composition.renderPage(pdf_painter, 0)
QgsMapLayerRegistry.instance().removeMapLayers([lyr.id() for lyr in layers])
cntr += 1
else:
QgsMapLayerRegistry.instance().removeMapLayers([lyr.id() for lyr in layers])
#output statistics
if len(self.statistics) > 0:
printer.setPaperSize(QSizeF(210, 297), QPrinter.Millimeter)
tabelle = self.__get_item_byid(self.comp_textinfo, 'TABELLE')
if tabelle is None:
self.iface.messageBar().pushMessage(u'Layout (Textinfo): Kein Textelement mit ID "TABELLE" vorhanden.', QgsMessageBar.CRITICAL)
else:
try:
str_flaechen = ''
idx = 0
for gnr, stats in self.statistics.iteritems():
comma = ', ' if idx > 0 else ''
str_flaechen += u'{0}{1} ({2:.2f}m²)'.format(comma, gnr, stats[0].flaeche)
idx += 1
lbls = self.__get_items(QgsComposerLabel, self.comp_textinfo)
self.__update_composer_items('', labels=lbls, gnrflaeche=str_flaechen)
html = tabelle.text()
html += u'<table>'
#gnrcnt = 0
for gnr, stats in self.statistics.iteritems():
#if gnrcnt > 0:
# html += u'<tr class="abstand"><td> </td><td> </td><td> </td></tr>'
html += u'<tr><th class="gnr"></th><th class="gnr">{0}</th><th class="gnr"></th></tr>'.format(gnr)
#html += u'<tr class="abstand"><td> </td><td> </td><td> </td></tr>'
curr_thema = ''
for stat in stats:
if stat.thema != curr_thema:
html += u'<tr><th class="thema"></th><th class="thema">{0}</th><th class="thema"></th></tr>'.format(stat.thema)
curr_thema = stat.thema
for thema, subthema in stat.subthemen.iteritems():
for quelle in subthema:
html += u'<tr><td class="col1">{0}</td>'.format(quelle.name)
attr_val = ''
attr_area = ''
for text, area in quelle.txt_area.iteritems():
attr_val += u'{0}<br />'.format(text)
attr_area += u'{0:.2f}m² <br />'.format(area)
html += u'<td class="col2">{0}</td><td class="col3">{1}</td></tr>'.format(attr_val, attr_area)
#gnrcnt += 1
html += u'</table>'
tabelle.setText(html)
printer.newPage()
self.comp_textinfo.renderPage(pdf_painter, 0)
except:
msg = 'Statistikausgabe:\n\n{0}'.format(traceback.format_exc())
QgsMessageLog.logMessage(msg, DLG_CAPTION)
self.iface.messageBar().pushMessage(msg, QgsMessageBar.CRITICAL)
except:
msg = 'export pdf (catch all):\n\n{0}'.format(traceback.format_exc())
QgsMessageLog.logMessage(msg, DLG_CAPTION)
self.iface.messageBar().pushMessage(msg.replace(u'\n', u''), QgsMessageBar.CRITICAL)
return msg
finally:
#end pdf
if not pdf_painter is None:
pdf_painter.end()
return None
class Map():
"""A class for creating a map."""
def __init__(self, iface):
"""Constructor for the Map class.
:param iface: Reference to the QGIS iface object.
:type iface: QgsAppInterface
"""
LOGGER.debug('InaSAFE Map class initialised')
self.iface = iface
self.layer = iface.activeLayer()
self.keyword_io = KeywordIO()
self.printer = None
self.composition = None
self.legend = None
self.logo = ':/plugins/inasafe/bnpb_logo.png'
self.template = ':/plugins/inasafe/inasafe.qpt'
#self.page_width = 210 # width in mm
#self.page_height = 297 # height in mm
self.page_width = 0 # width in mm
self.page_height = 0 # height in mm
self.page_dpi = 300.0
#self.page_margin = 10 # margin in mm
self.show_frames = False # intended for debugging use only
self.page_margin = None
#vertical spacing between elements
self.vertical_spacing = None
self.map_height = None
self.mapWidth = None
# make a square map where width = height = page width
#self.map_height = self.page_width - (self.page_margin * 2)
#self.mapWidth = self.map_height
#self.disclaimer = self.tr('InaSAFE has been jointly developed by'
# ' BNPB, AusAid & the World Bank')
@staticmethod
def tr(string):
"""We implement this since we do not inherit QObject.
:param string: String for translation.
:type string: QString, str
:returns: Translated version of theString.
:rtype: QString
"""
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
return QtCore.QCoreApplication.translate('Map', string)
def set_impact_layer(self, layer):
"""Set the layer that will be used for stats, legend and reporting.
:param layer: Layer that will be used for stats, legend and reporting.
:type layer: QgsMapLayer, QgsRasterLayer, QgsVectorLayer
"""
self.layer = layer
def set_logo(self, logo):
"""
:param logo: Path to image that will be used as logo in report
:type logo: str
"""
self.logo = logo
def set_template(self, template):
"""
:param template: Path to composer template that will be used for report
:type template: str
"""
self.template = template
def setup_composition(self):
"""Set up the composition ready for drawing elements onto it."""
LOGGER.debug('InaSAFE Map setupComposition called')
canvas = self.iface.mapCanvas()
renderer = canvas.mapRenderer()
self.composition = QgsComposition(renderer)
self.composition.setPlotStyle(QgsComposition.Print) # or preview
#self.composition.setPaperSize(self.page_width, self.page_height)
self.composition.setPrintResolution(self.page_dpi)
self.composition.setPrintAsRaster(True)
def compose_map(self):
"""Place all elements on the map ready for printing."""
self.setup_composition()
# Keep track of our vertical positioning as we work our way down
# the page placing elements on it.
top_offset = self.page_margin
self.draw_logo(top_offset)
label_height = self.draw_title(top_offset)
# Update the map offset for the next row of content
top_offset += label_height + self.vertical_spacing
composer_map = self.draw_map(top_offset)
self.draw_scalebar(composer_map, top_offset)
# Update the top offset for the next horizontal row of items
top_offset += self.map_height + self.vertical_spacing - 1
impact_title_height = self.draw_impact_title(top_offset)
# Update the top offset for the next horizontal row of items
if impact_title_height:
top_offset += impact_title_height + self.vertical_spacing + 2
self.draw_legend(top_offset)
self.draw_host_and_time(top_offset)
self.draw_disclaimer()
def render(self):
"""Render the map composition to an image and save that to disk.
:returns: A three-tuple of:
* str: image_path - absolute path to png of rendered map
* QImage: image - in memory copy of rendered map
* QRectF: target_area - dimensions of rendered map
:rtype: tuple
"""
LOGGER.debug('InaSAFE Map renderComposition called')
# NOTE: we ignore self.composition.printAsRaster() and always rasterise
width = int(self.page_dpi * self.page_width / 25.4)
height = int(self.page_dpi * self.page_height / 25.4)
image = QtGui.QImage(
QtCore.QSize(width, height),
QtGui.QImage.Format_ARGB32)
image.setDotsPerMeterX(dpi_to_meters(self.page_dpi))
image.setDotsPerMeterY(dpi_to_meters(self.page_dpi))
# Only works in Qt4.8
#image.fill(QtGui.qRgb(255, 255, 255))
# Works in older Qt4 versions
image.fill(55 + 255 * 256 + 255 * 256 * 256)
image_painter = QtGui.QPainter(image)
source_area = QtCore.QRectF(
0, 0, self.page_width,
self.page_height)
target_area = QtCore.QRectF(0, 0, width, height)
self.composition.render(image_painter, target_area, source_area)
image_painter.end()
image_path = unique_filename(
prefix='mapRender_',
suffix='.png',
dir=temp_dir())
image.save(image_path)
return image_path, image, target_area
def make_pdf(self, filename):
"""Generate the printout for our final map.
:param filename: Path on the file system to which the pdf should be
saved. If None, a generated file name will be used.
:type filename: str
:returns: File name of the output file (equivalent to filename if
provided).
:rtype: str
"""
LOGGER.debug('InaSAFE Map printToPdf called')
if filename is None:
map_pdf_path = unique_filename(
prefix='report', suffix='.pdf', dir=temp_dir())
else:
# We need to cast to python string in case we receive a QString
map_pdf_path = str(filename)
self.load_template()
resolution = self.composition.printResolution()
self.printer = setup_printer(map_pdf_path, resolution=resolution)
_, image, rectangle = self.render()
painter = QtGui.QPainter(self.printer)
painter.drawImage(rectangle, image, rectangle)
painter.end()
return map_pdf_path
def draw_logo(self, top_offset):
"""Add a picture containing the logo to the map top left corner
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
logo = QgsComposerPicture(self.composition)
logo.setPictureFile(':/plugins/inasafe/bnpb_logo.png')
logo.setItemPosition(self.page_margin, top_offset, 10, 10)
logo.setFrameEnabled(self.show_frames)
logo.setZValue(1) # To ensure it overlays graticule markers
self.composition.addItem(logo)
def draw_title(self, top_offset):
"""Add a title to the composition.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The height of the label as rendered.
:rtype: float
"""
LOGGER.debug('InaSAFE Map drawTitle called')
font_size = 14
font_weight = QtGui.QFont.Bold
italics_flag = False
font = QtGui.QFont(
'verdana',
font_size,
font_weight,
italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
heading = self.tr(
'InaSAFE - Indonesia Scenario Assessment for Emergencies')
label.setText(heading)
label.adjustSizeToText()
label_height = 10.0 # determined using qgis map composer
label_width = 170.0 # item - position and size...option
left_offset = self.page_width - self.page_margin - label_width
label.setItemPosition(
left_offset,
top_offset - 2, # -2 to push it up a little
label_width,
label_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
return label_height
def draw_map(self, top_offset):
"""Add a map to the composition and return the composer map instance.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The composer map.
:rtype: QgsComposerMap
"""
LOGGER.debug('InaSAFE Map drawMap called')
map_width = self.mapWidth
composer_map = QgsComposerMap(
self.composition,
self.page_margin,
top_offset,
map_width,
self.map_height)
#myExtent = self.iface.mapCanvas().extent()
# The dimensions of the map canvas and the print composer map may
# differ. So we set the map composer extent using the canvas and
# then defer to the map canvas's map extents thereafter
# Update: disabled as it results in a rectangular rather than
# square map
#composer_map.setNewExtent(myExtent)
composer_extent = composer_map.extent()
# Recenter the composer map on the center of the canvas
# Note that since the composer map is square and the canvas may be
# arbitrarily shaped, we center based on the longest edge
canvas_extent = self.iface.mapCanvas().extent()
width = canvas_extent.width()
height = canvas_extent.height()
longest_length = width
if width < height:
longest_length = height
half_length = longest_length / 2
center = canvas_extent.center()
min_x = center.x() - half_length
max_x = center.x() + half_length
min_y = center.y() - half_length
max_y = center.y() + half_length
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
composer_map.setNewExtent(square_extent)
composer_map.setGridEnabled(True)
split_count = 5
# .. todo:: Write logic to adjust precision so that adjacent tick marks
# always have different displayed values
precision = 2
x_interval = composer_extent.width() / split_count
composer_map.setGridIntervalX(x_interval)
y_interval = composer_extent.height() / split_count
composer_map.setGridIntervalY(y_interval)
composer_map.setGridStyle(QgsComposerMap.Cross)
cross_length_mm = 1
composer_map.setCrossLength(cross_length_mm)
composer_map.setZValue(0) # To ensure it does not overlay logo
font_size = 6
font_weight = QtGui.QFont.Normal
italics_flag = False
font = QtGui.QFont(
'verdana',
font_size,
font_weight,
italics_flag)
composer_map.setGridAnnotationFont(font)
composer_map.setGridAnnotationPrecision(precision)
composer_map.setShowGridAnnotation(True)
composer_map.setGridAnnotationDirection(
QgsComposerMap.BoundaryDirection, QgsComposerMap.Top)
self.composition.addItem(composer_map)
self.draw_graticule_mask(top_offset)
return composer_map
def draw_graticule_mask(self, top_offset):
"""A helper function to mask out graticule labels.
It will hide labels on the right side by over painting a white
rectangle with white border on them. **kludge**
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawGraticuleMask called')
left_offset = self.page_margin + self.mapWidth
rect = QgsComposerShape(
left_offset + 0.5,
top_offset,
self.page_width - left_offset,
self.map_height + 1,
self.composition)
rect.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setColor(QtGui.QColor(0, 0, 0))
pen.setWidthF(0.1)
rect.setPen(pen)
rect.setBackgroundColor(QtGui.QColor(255, 255, 255))
rect.setTransparency(100)
#rect.setLineWidth(0.1)
#rect.setFrameEnabled(False)
#rect.setOutlineColor(QtGui.QColor(255, 255, 255))
#rect.setFillColor(QtGui.QColor(255, 255, 255))
#rect.setOpacity(100)
# These two lines seem superfluous but are needed
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
rect.setBrush(brush)
self.composition.addItem(rect)
def draw_native_scalebar(self, composer_map, top_offset):
"""Draw a scale bar using QGIS' native drawing.
In the case of geographic maps, scale will be in degrees, not km.
:param composer_map: Composer map on which to draw the scalebar.
:type composer_map: QgsComposerMap
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawNativeScaleBar called')
scale_bar = QgsComposerScaleBar(self.composition)
scale_bar.setStyle('Numeric') # optionally modify the style
scale_bar.setComposerMap(composer_map)
scale_bar.applyDefaultSize()
scale_bar_height = scale_bar.boundingRect().height()
scale_bar_width = scale_bar.boundingRect().width()
# -1 to avoid overlapping the map border
scale_bar.setItemPosition(
self.page_margin + 1,
top_offset + self.map_height - (scale_bar_height * 2),
scale_bar_width,
scale_bar_height)
scale_bar.setFrameEnabled(self.show_frames)
# Disabled for now
#self.composition.addItem(scale_bar)
def draw_scalebar(self, composer_map, top_offset):
"""Add a numeric scale to the bottom left of the map.
We draw the scale bar manually because QGIS does not yet support
rendering a scale bar for a geographic map in km.
.. seealso:: :meth:`drawNativeScaleBar`
:param composer_map: Composer map on which to draw the scalebar.
:type composer_map: QgsComposerMap
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawScaleBar called')
canvas = self.iface.mapCanvas()
renderer = canvas.mapRenderer()
#
# Add a linear map scale
#
distance_area = QgsDistanceArea()
distance_area.setSourceCrs(renderer.destinationCrs().srsid())
distance_area.setEllipsoidalMode(True)
# Determine how wide our map is in km/m
# Starting point at BL corner
composer_extent = composer_map.extent()
start_point = QgsPoint(
composer_extent.xMinimum(),
composer_extent.yMinimum())
# Ending point at BR corner
end_point = QgsPoint(
composer_extent.xMaximum(),
composer_extent.yMinimum())
ground_distance = distance_area.measureLine(start_point, end_point)
# Get the equivalent map distance per page mm
map_width = self.mapWidth
# How far is 1mm on map on the ground in meters?
mm_to_ground = ground_distance / map_width
#print 'MM:', myMMDistance
# How long we want the scale bar to be in relation to the map
scalebar_to_map_ratio = 0.5
# How many divisions the scale bar should have
tick_count = 5
scale_bar_width_mm = map_width * scalebar_to_map_ratio
print_segment_width_mm = scale_bar_width_mm / tick_count
# Segment width in real world (m)
# We apply some logic here so that segments are displayed in meters
# if each segment is less that 1000m otherwise km. Also the segment
# lengths are rounded down to human looking numbers e.g. 1km not 1.1km
units = ''
ground_segment_width = print_segment_width_mm * mm_to_ground
if ground_segment_width < 1000:
units = 'm'
ground_segment_width = round(ground_segment_width)
# adjust the segment width now to account for rounding
print_segment_width_mm = ground_segment_width / mm_to_ground
else:
units = 'km'
# Segment with in real world (km)
ground_segment_width = round(ground_segment_width / 1000)
print_segment_width_mm = (
(ground_segment_width * 1000) / mm_to_ground)
# Now adjust the scalebar width to account for rounding
scale_bar_width_mm = tick_count * print_segment_width_mm
#print "SBWMM:", scale_bar_width_mm
#print "SWMM:", print_segment_width_mm
#print "SWM:", myGroundSegmentWidthM
#print "SWKM:", myGroundSegmentWidthKM
# start drawing in line segments
scalebar_height = 5 # mm
line_width = 0.3 # mm
inset_distance = 7 # how much to inset the scalebar into the map by
scalebar_x = self.page_margin + inset_distance
scalebar_y = (
top_offset + self.map_height - inset_distance -
scalebar_height) # mm
# Draw an outer background box - shamelessly hardcoded buffer
rectangle = QgsComposerShape(
scalebar_x - 4, # left edge
scalebar_y - 3, # top edge
scale_bar_width_mm + 13, # right edge
scalebar_height + 6, # bottom edge
self.composition)
rectangle.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setColor(QtGui.QColor(255, 255, 255))
pen.setWidthF(line_width)
rectangle.setPen(pen)
#rectangle.setLineWidth(line_width)
rectangle.setFrameEnabled(False)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
# workaround for missing setTransparentFill missing from python api
rectangle.setBrush(brush)
self.composition.addItem(rectangle)
# Set up the tick label font
font_weight = QtGui.QFont.Normal
font_size = 6
italics_flag = False
font = QtGui.QFont(
'verdana',
font_size,
font_weight,
italics_flag)
# Draw the bottom line
up_shift = 0.3 # shift the bottom line up for better rendering
rectangle = QgsComposerShape(
scalebar_x,
scalebar_y + scalebar_height - up_shift,
scale_bar_width_mm,
0.1,
self.composition)
rectangle.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setColor(QtGui.QColor(255, 255, 255))
pen.setWidthF(line_width)
rectangle.setPen(pen)
#rectangle.setLineWidth(line_width)
rectangle.setFrameEnabled(False)
self.composition.addItem(rectangle)
# Now draw the scalebar ticks
for tick_counter in range(0, tick_count + 1):
distance_suffix = ''
if tick_counter == tick_count:
distance_suffix = ' ' + units
real_world_distance = (
'%.0f%s' %
(tick_counter *
ground_segment_width,
distance_suffix))
#print 'RW:', myRealWorldDistance
mm_offset = scalebar_x + (
tick_counter * print_segment_width_mm)
#print 'MM:', mm_offset
tick_height = scalebar_height / 2
# Lines are not exposed by the api yet so we
# bodge drawing lines using rectangles with 1px height or width
tick_width = 0.1 # width or rectangle to be drawn
uptick_line = QgsComposerShape(
mm_offset,
scalebar_y + scalebar_height - tick_height,
tick_width,
tick_height,
self.composition)
uptick_line.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setWidthF(line_width)
uptick_line.setPen(pen)
#uptick_line.setLineWidth(line_width)
uptick_line.setFrameEnabled(False)
self.composition.addItem(uptick_line)
#
# Add a tick label
#
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(real_world_distance)
label.adjustSizeToText()
label.setItemPosition(
mm_offset - 3,
scalebar_y - tick_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
def draw_impact_title(self, top_offset):
"""Draw the map subtitle - obtained from the impact layer keywords.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The height of the label as rendered.
:rtype: float
"""
LOGGER.debug('InaSAFE Map drawImpactTitle called')
title = self.map_title()
if title is None:
title = ''
font_size = 20
font_weight = QtGui.QFont.Bold
italics_flag = False
font = QtGui.QFont(
'verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
heading = title
label.setText(heading)
label_width = self.page_width - (self.page_margin * 2)
label_height = 12
label.setItemPosition(
self.page_margin, top_offset, label_width, label_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
return label_height
def draw_legend(self, top_offset):
"""Add a legend to the map using our custom legend renderer.
.. note:: getLegend generates a pixmap in 150dpi so if you set
the map to a higher dpi it will appear undersized.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawLegend called')
legend_attributes = self.map_legend_attributes()
legend_notes = legend_attributes.get('legend_notes', None)
legend_units = legend_attributes.get('legend_units', None)
legend_title = legend_attributes.get('legend_title', None)
LOGGER.debug(legend_attributes)
legend = MapLegend(
self.layer,
self.page_dpi,
legend_title,
legend_notes,
legend_units)
self.legend = legend.get_legend()
picture1 = QgsComposerPicture(self.composition)
legend_file_path = unique_filename(
prefix='legend', suffix='.png', dir='work')
self.legend.save(legend_file_path, 'PNG')
picture1.setPictureFile(legend_file_path)
legend_height = points_to_mm(self.legend.height(), self.page_dpi)
legend_width = points_to_mm(self.legend.width(), self.page_dpi)
picture1.setItemPosition(
self.page_margin,
top_offset,
legend_width,
legend_height)
picture1.setFrameEnabled(False)
self.composition.addItem(picture1)
os.remove(legend_file_path)
def draw_image(self, image, width_mm, left_offset, top_offset):
"""Helper to draw an image directly onto the QGraphicsScene.
This is an alternative to using QgsComposerPicture which in
some cases leaves artifacts under windows.
The Pixmap will have a transform applied to it so that
it is rendered with the same resolution as the composition.
:param image: Image that will be rendered to the layout.
:type image: QImage
:param width_mm: Desired width in mm of output on page.
:type width_mm: int
:param left_offset: Offset from left of page.
:type left_offset: int
:param top_offset: Offset from top of page.
:type top_offset: int
:returns: Graphics scene item.
:rtype: QGraphicsSceneItem
"""
LOGGER.debug('InaSAFE Map drawImage called')
desired_width_mm = width_mm # mm
desired_width_px = mm_to_points(desired_width_mm, self.page_dpi)
actual_width_px = image.width()
scale_factor = desired_width_px / actual_width_px
LOGGER.debug('%s %s %s' % (
scale_factor, actual_width_px, desired_width_px))
transform = QtGui.QTransform()
transform.scale(scale_factor, scale_factor)
transform.rotate(0.5)
# noinspection PyArgumentList
item = self.composition.addPixmap(QtGui.QPixmap.fromImage(image))
item.setTransform(transform)
item.setOffset(
left_offset / scale_factor, top_offset / scale_factor)
return item
def draw_host_and_time(self, top_offset):
"""Add a note with hostname and time to the composition.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawDisclaimer called')
#elapsed_time: 11.612545
#user: timlinux
#host_name: ultrabook
#time_stamp: 2012-10-13_23:10:31
#myUser = self.keyword_io.readKeywords(self.layer, 'user')
#myHost = self.keyword_io.readKeywords(self.layer, 'host_name')
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
#myElapsedTime = self.keyword_io.readKeywords(self.layer,
# 'elapsed_time')
#myElapsedTime = humaniseSeconds(myElapsedTime)
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
label_text = self.tr(
'Date and time of assessment: %s %s\n'
'Special note: This assessment is a guide - we strongly recommend '
'that you ground truth the results shown here before deploying '
'resources and / or personnel.\n'
'Assessment carried out using InaSAFE release %s (QGIS '
'plugin version).') % (date, time, version)
font_size = 6
font_weight = QtGui.QFont.Normal
italics_flag = True
font = QtGui.QFont(
'verdana',
font_size,
font_weight,
italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(label_text)
label.adjustSizeToText()
label_height = 50.0 # mm determined using qgis map composer
label_width = (self.page_width / 2) - self.page_margin
left_offset = self.page_width / 2 # put in right half of page
label.setItemPosition(
left_offset,
top_offset,
label_width,
label_height,)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
def draw_disclaimer(self):
"""Add a disclaimer to the composition."""
LOGGER.debug('InaSAFE Map drawDisclaimer called')
font_size = 10
font_weight = QtGui.QFont.Normal
italics_flag = True
font = QtGui.QFont(
'verdana',
font_size,
font_weight,
italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(self.disclaimer)
label.adjustSizeToText()
label_height = 7.0 # mm determined using qgis map composer
label_width = self.page_width # item - position and size...option
left_offset = self.page_margin
top_offset = self.page_height - self.page_margin
label.setItemPosition(
left_offset,
top_offset,
label_width,
label_height,)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
def map_title(self):
"""Get the map title from the layer keywords if possible.
:returns: None on error, otherwise the title.
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapTitle called')
try:
title = self.keyword_io.read_keywords(self.layer, 'map_title')
return title
except KeywordNotFoundError:
return None
except Exception:
return None
def map_legend_attributes(self):
"""Get the map legend attribute from the layer keywords if possible.
:returns: None on error, otherwise the attributes (notes and units).
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapLegendAtributes called')
legend_attribute_list = [
'legend_notes',
'legend_units',
'legend_title']
legend_attribute_dict = {}
for myLegendAttribute in legend_attribute_list:
try:
legend_attribute_dict[myLegendAttribute] = \
self.keyword_io.read_keywords(
self.layer, myLegendAttribute)
except KeywordNotFoundError:
pass
except Exception:
pass
return legend_attribute_dict
def show_composer(self):
"""Show the composition in a composer view so the user can tweak it.
"""
view = QgsComposerView(self.iface.mainWindow())
view.show()
def write_template(self, template_path):
"""Write current composition as a template that can be re-used in QGIS.
:param template_path: Path to which template should be written.
:type template_path: str
"""
document = QtXml.QDomDocument()
element = document.createElement('Composer')
document.appendChild(element)
self.composition.writeXML(element, document)
xml = document.toByteArray()
template_file = file(template_path, 'wb')
template_file.write(xml)
template_file.close()
def load_template(self):
"""Load a QgsComposer map from a template and render it.
.. note:: THIS METHOD IS EXPERIMENTAL
"""
self.setup_composition()
template_file = QtCore.QFile(self.template)
template_file.open(QtCore.QIODevice.ReadOnly | QtCore.QIODevice.Text)
template_content = template_file.readAll()
template_file.close()
document = QtXml.QDomDocument()
document.setContent(template_content)
# get information for substitutions
# date, time and plugin version
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
# map title
LOGGER.debug('InaSAFE Map getMapTitle called')
try:
title = self.keyword_io.read_keywords(self.layer, 'map_title')
except KeywordNotFoundError:
title = None
except Exception:
title = None
if not title:
title = ''
substitution_map = {
'impact-title': title,
'date': date,
'time': time,
'safe-version': version
}
LOGGER.debug(substitution_map)
load_ok = self.composition.loadFromTemplate(document,
substitution_map)
if not load_ok:
raise ReportCreationError(
self.tr('Error loading template %s') %
self.template)
self.page_width = self.composition.paperWidth()
self.page_height = self.composition.paperHeight()
# set logo
image = self.composition.getComposerItemById('safe-logo')
image.setPictureFile(self.logo)
# Get the main map canvas on the composition and set
# its extents to the event.
map = self.composition.getComposerItemById('impact-map')
if map is not None:
# Recenter the composer map on the center of the canvas
# Note that since the composer map is square and the canvas may be
# arbitrarily shaped, we center based on the longest edge
canvas_extent = self.iface.mapCanvas().extent()
width = canvas_extent.width()
height = canvas_extent.height()
longest_width = width
if width < height:
longest_width = height
half_length = longest_width / 2
center = canvas_extent.center()
min_x = center.x() - half_length
max_x = center.x() + half_length
min_y = center.y() - half_length
max_y = center.y() + half_length
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
map.setNewExtent(square_extent)
# calculate intervals for grid
split_count = 5
x_interval = square_extent.width() / split_count
map.setGridIntervalX(x_interval)
y_interval = square_extent.height() / split_count
map.setGridIntervalY(y_interval)
else:
raise ReportCreationError(self.tr(
'Map "impact-map" could not be found'))
legend = self.composition.getComposerItemById('impact-legend')
legend_attributes = self.map_legend_attributes()
LOGGER.debug(legend_attributes)
#legend_notes = mapLegendAttributes.get('legend_notes', None)
#legend_units = mapLegendAttributes.get('legend_units', None)
legend_title = legend_attributes.get('legend_title', None)
if legend_title is None:
legend_title = ""
legend.setTitle(legend_title)
legend.updateLegend()
class Map():
"""A class for creating a map."""
def __init__(self, iface):
"""Constructor for the Map class.
:param iface: Reference to the QGIS iface object.
:type iface: QgsAppInterface
"""
LOGGER.debug('InaSAFE Map class initialised')
self.iface = iface
self.layer = iface.activeLayer()
self.keyword_io = KeywordIO()
self.printer = None
self.composition = None
self.extent = iface.mapCanvas().extent()
self.logo = ':/plugins/inasafe/bnpb_logo.png'
self.template = ':/plugins/inasafe/inasafe.qpt'
self.page_width = 0 # width in mm
self.page_height = 0 # height in mm
self.page_dpi = 300.0
self.show_frames = False # intended for debugging use only
@staticmethod
def tr(string):
"""We implement this since we do not inherit QObject.
:param string: String for translation.
:type string: QString, str
:returns: Translated version of theString.
:rtype: QString
"""
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
return QtCore.QCoreApplication.translate('Map', string)
def set_impact_layer(self, layer):
"""Set the layer that will be used for stats, legend and reporting.
:param layer: Layer that will be used for stats, legend and reporting.
:type layer: QgsMapLayer, QgsRasterLayer, QgsVectorLayer
"""
self.layer = layer
def set_logo(self, logo):
"""Set image that will be used as logo in reports.
:param logo: Path to image file
:type logo: str
"""
self.logo = logo
def set_template(self, template):
"""Set template that will be used for report generation.
:param template: Path to composer template
:type template: str
"""
self.template = template
def set_extent(self, extent):
"""Set extent or the report map
:param extent: Extent of the report map
:type extent: QgsRectangle
"""
self.extent = extent
def setup_composition(self):
"""Set up the composition ready for drawing elements onto it."""
LOGGER.debug('InaSAFE Map setupComposition called')
canvas = self.iface.mapCanvas()
renderer = canvas.mapRenderer()
self.composition = QgsComposition(renderer)
self.composition.setPlotStyle(QgsComposition.Print) # or preview
self.composition.setPrintResolution(self.page_dpi)
self.composition.setPrintAsRaster(True)
def render(self):
"""Render the map composition to an image and save that to disk.
:returns: A three-tuple of:
* str: image_path - absolute path to png of rendered map
* QImage: image - in memory copy of rendered map
* QRectF: target_area - dimensions of rendered map
:rtype: tuple
"""
LOGGER.debug('InaSAFE Map renderComposition called')
# NOTE: we ignore self.composition.printAsRaster() and always rasterize
width = int(self.page_dpi * self.page_width / 25.4)
height = int(self.page_dpi * self.page_height / 25.4)
image = QtGui.QImage(
QtCore.QSize(width, height),
QtGui.QImage.Format_ARGB32)
image.setDotsPerMeterX(dpi_to_meters(self.page_dpi))
image.setDotsPerMeterY(dpi_to_meters(self.page_dpi))
# Only works in Qt4.8
#image.fill(QtGui.qRgb(255, 255, 255))
# Works in older Qt4 versions
image.fill(55 + 255 * 256 + 255 * 256 * 256)
image_painter = QtGui.QPainter(image)
source_area = QtCore.QRectF(
0, 0, self.page_width,
self.page_height)
target_area = QtCore.QRectF(0, 0, width, height)
self.composition.render(image_painter, target_area, source_area)
image_painter.end()
image_path = unique_filename(
prefix='mapRender_',
suffix='.png',
dir=temp_dir())
image.save(image_path)
return image_path, image, target_area
def make_pdf(self, filename):
"""Generate the printout for our final map.
:param filename: Path on the file system to which the pdf should be
saved. If None, a generated file name will be used.
:type filename: str
:returns: File name of the output file (equivalent to filename if
provided).
:rtype: str
"""
LOGGER.debug('InaSAFE Map printToPdf called')
if filename is None:
map_pdf_path = unique_filename(
prefix='report', suffix='.pdf', dir=temp_dir())
else:
# We need to cast to python string in case we receive a QString
map_pdf_path = str(filename)
self.load_template()
resolution = self.composition.printResolution()
self.printer = setup_printer(map_pdf_path, resolution=resolution)
_, image, rectangle = self.render()
painter = QtGui.QPainter(self.printer)
painter.drawImage(rectangle, image, rectangle)
painter.end()
return map_pdf_path
def map_title(self):
"""Get the map title from the layer keywords if possible.
:returns: None on error, otherwise the title.
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapTitle called')
try:
title = self.keyword_io.read_keywords(self.layer, 'map_title')
return title
except KeywordNotFoundError:
return None
except Exception:
return None
def map_legend_attributes(self):
"""Get the map legend attribute from the layer keywords if possible.
:returns: None on error, otherwise the attributes (notes and units).
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapLegendAtributes called')
legend_attribute_list = [
'legend_notes',
'legend_units',
'legend_title']
legend_attribute_dict = {}
for myLegendAttribute in legend_attribute_list:
try:
legend_attribute_dict[myLegendAttribute] = \
self.keyword_io.read_keywords(
self.layer, myLegendAttribute)
except KeywordNotFoundError:
pass
except Exception:
pass
return legend_attribute_dict
def load_template(self):
"""Load a QgsComposer map from a template.
"""
self.setup_composition()
template_file = QtCore.QFile(self.template)
template_file.open(QtCore.QIODevice.ReadOnly | QtCore.QIODevice.Text)
template_content = template_file.readAll()
template_file.close()
document = QtXml.QDomDocument()
document.setContent(template_content)
# get information for substitutions
# date, time and plugin version
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
if date_time is None:
date = ''
time = ''
else:
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
title = self.map_title()
if not title:
title = ''
substitution_map = {
'impact-title': title,
'date': date,
'time': time,
'safe-version': version
}
LOGGER.debug(substitution_map)
load_ok = self.composition.loadFromTemplate(document,
substitution_map)
if not load_ok:
raise ReportCreationError(
self.tr('Error loading template %s') %
self.template)
self.page_width = self.composition.paperWidth()
self.page_height = self.composition.paperHeight()
# set logo
image = self.composition.getComposerItemById('safe-logo')
if image is not None:
image.setPictureFile(self.logo)
else:
raise ReportCreationError(self.tr(
'Image "safe-logo" could not be found'))
# Get the main map canvas on the composition and set
# its extents to the event.
composer_map = self.composition.getComposerItemById('impact-map')
if composer_map is not None:
# Recenter the composer map on the center of the extent
# Note that since the composer map is square and the canvas may be
# arbitrarily shaped, we center based on the longest edge
canvas_extent = self.extent
width = canvas_extent.width()
height = canvas_extent.height()
longest_width = width
if width < height:
longest_width = height
half_length = longest_width / 2
center = canvas_extent.center()
min_x = center.x() - half_length
max_x = center.x() + half_length
min_y = center.y() - half_length
max_y = center.y() + half_length
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
composer_map.setNewExtent(square_extent)
# calculate intervals for grid
split_count = 5
x_interval = square_extent.width() / split_count
composer_map.setGridIntervalX(x_interval)
y_interval = square_extent.height() / split_count
composer_map.setGridIntervalY(y_interval)
else:
raise ReportCreationError(self.tr(
'Map "impact-map" could not be found'))
legend = self.composition.getComposerItemById('impact-legend')
legend_attributes = self.map_legend_attributes()
LOGGER.debug(legend_attributes)
#legend_notes = mapLegendAttributes.get('legend_notes', None)
#legend_units = mapLegendAttributes.get('legend_units', None)
legend_title = legend_attributes.get('legend_title', None)
if legend_title is None:
legend_title = ""
legend.setTitle(legend_title)
legend.updateLegend()
class Map():
"""A class for creating a map."""
def __init__(self, iface):
"""Constructor for the Map class.
:param iface: Reference to the QGIS iface object.
:type iface: QgsAppInterface
"""
LOGGER.debug('InaSAFE Map class initialised')
self.iface = iface
self.layer = iface.activeLayer()
self.keyword_io = KeywordIO()
self.printer = None
self.composition = None
self.legend = None
self.logo = ':/plugins/inasafe/bnpb_logo.png'
self.template = ':/plugins/inasafe/inasafe.qpt'
#self.page_width = 210 # width in mm
#self.page_height = 297 # height in mm
self.page_width = 0 # width in mm
self.page_height = 0 # height in mm
self.page_dpi = 300.0
#self.page_margin = 10 # margin in mm
self.show_frames = False # intended for debugging use only
self.page_margin = None
#vertical spacing between elements
self.vertical_spacing = None
self.map_height = None
self.mapWidth = None
# make a square map where width = height = page width
#self.map_height = self.page_width - (self.page_margin * 2)
#self.mapWidth = self.map_height
#self.disclaimer = self.tr('InaSAFE has been jointly developed by'
# ' BNPB, AusAid & the World Bank')
@staticmethod
def tr(string):
"""We implement this since we do not inherit QObject.
:param string: String for translation.
:type string: QString, str
:returns: Translated version of theString.
:rtype: QString
"""
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
return QtCore.QCoreApplication.translate('Map', string)
def set_impact_layer(self, layer):
"""Set the layer that will be used for stats, legend and reporting.
:param layer: Layer that will be used for stats, legend and reporting.
:type layer: QgsMapLayer, QgsRasterLayer, QgsVectorLayer
"""
self.layer = layer
def set_logo(self, logo):
"""
:param logo: Path to image that will be used as logo in report
:type logo: str
"""
self.logo = logo
def set_template(self, template):
"""
:param template: Path to composer template that will be used for report
:type template: str
"""
self.template = template
def setup_composition(self):
"""Set up the composition ready for drawing elements onto it."""
LOGGER.debug('InaSAFE Map setupComposition called')
canvas = self.iface.mapCanvas()
renderer = canvas.mapRenderer()
self.composition = QgsComposition(renderer)
self.composition.setPlotStyle(QgsComposition.Print) # or preview
#self.composition.setPaperSize(self.page_width, self.page_height)
self.composition.setPrintResolution(self.page_dpi)
self.composition.setPrintAsRaster(True)
def compose_map(self):
"""Place all elements on the map ready for printing."""
self.setup_composition()
# Keep track of our vertical positioning as we work our way down
# the page placing elements on it.
top_offset = self.page_margin
self.draw_logo(top_offset)
label_height = self.draw_title(top_offset)
# Update the map offset for the next row of content
top_offset += label_height + self.vertical_spacing
composer_map = self.draw_map(top_offset)
self.draw_scalebar(composer_map, top_offset)
# Update the top offset for the next horizontal row of items
top_offset += self.map_height + self.vertical_spacing - 1
impact_title_height = self.draw_impact_title(top_offset)
# Update the top offset for the next horizontal row of items
if impact_title_height:
top_offset += impact_title_height + self.vertical_spacing + 2
self.draw_legend(top_offset)
self.draw_host_and_time(top_offset)
self.draw_disclaimer()
def render(self):
"""Render the map composition to an image and save that to disk.
:returns: A three-tuple of:
* str: image_path - absolute path to png of rendered map
* QImage: image - in memory copy of rendered map
* QRectF: target_area - dimensions of rendered map
:rtype: tuple
"""
LOGGER.debug('InaSAFE Map renderComposition called')
# NOTE: we ignore self.composition.printAsRaster() and always rasterise
width = int(self.page_dpi * self.page_width / 25.4)
height = int(self.page_dpi * self.page_height / 25.4)
image = QtGui.QImage(QtCore.QSize(width, height),
QtGui.QImage.Format_ARGB32)
image.setDotsPerMeterX(dpi_to_meters(self.page_dpi))
image.setDotsPerMeterY(dpi_to_meters(self.page_dpi))
# Only works in Qt4.8
#image.fill(QtGui.qRgb(255, 255, 255))
# Works in older Qt4 versions
image.fill(55 + 255 * 256 + 255 * 256 * 256)
image_painter = QtGui.QPainter(image)
source_area = QtCore.QRectF(0, 0, self.page_width, self.page_height)
target_area = QtCore.QRectF(0, 0, width, height)
self.composition.render(image_painter, target_area, source_area)
image_painter.end()
image_path = unique_filename(prefix='mapRender_',
suffix='.png',
dir=temp_dir())
image.save(image_path)
return image_path, image, target_area
def make_pdf(self, filename):
"""Generate the printout for our final map.
:param filename: Path on the file system to which the pdf should be
saved. If None, a generated file name will be used.
:type filename: str
:returns: File name of the output file (equivalent to filename if
provided).
:rtype: str
"""
LOGGER.debug('InaSAFE Map printToPdf called')
if filename is None:
map_pdf_path = unique_filename(prefix='report',
suffix='.pdf',
dir=temp_dir())
else:
# We need to cast to python string in case we receive a QString
map_pdf_path = str(filename)
self.load_template()
resolution = self.composition.printResolution()
self.printer = setup_printer(map_pdf_path, resolution=resolution)
_, image, rectangle = self.render()
painter = QtGui.QPainter(self.printer)
painter.drawImage(rectangle, image, rectangle)
painter.end()
return map_pdf_path
def draw_logo(self, top_offset):
"""Add a picture containing the logo to the map top left corner
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
logo = QgsComposerPicture(self.composition)
logo.setPictureFile(':/plugins/inasafe/bnpb_logo.png')
logo.setItemPosition(self.page_margin, top_offset, 10, 10)
logo.setFrameEnabled(self.show_frames)
logo.setZValue(1) # To ensure it overlays graticule markers
self.composition.addItem(logo)
def draw_title(self, top_offset):
"""Add a title to the composition.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The height of the label as rendered.
:rtype: float
"""
LOGGER.debug('InaSAFE Map drawTitle called')
font_size = 14
font_weight = QtGui.QFont.Bold
italics_flag = False
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
heading = self.tr(
'InaSAFE - Indonesia Scenario Assessment for Emergencies')
label.setText(heading)
label.adjustSizeToText()
label_height = 10.0 # determined using qgis map composer
label_width = 170.0 # item - position and size...option
left_offset = self.page_width - self.page_margin - label_width
label.setItemPosition(
left_offset,
top_offset - 2, # -2 to push it up a little
label_width,
label_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
return label_height
def draw_map(self, top_offset):
"""Add a map to the composition and return the composer map instance.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The composer map.
:rtype: QgsComposerMap
"""
LOGGER.debug('InaSAFE Map drawMap called')
map_width = self.mapWidth
composer_map = QgsComposerMap(self.composition, self.page_margin,
top_offset, map_width, self.map_height)
#myExtent = self.iface.mapCanvas().extent()
# The dimensions of the map canvas and the print composer map may
# differ. So we set the map composer extent using the canvas and
# then defer to the map canvas's map extents thereafter
# Update: disabled as it results in a rectangular rather than
# square map
#composer_map.setNewExtent(myExtent)
composer_extent = composer_map.extent()
# Recenter the composer map on the center of the canvas
# Note that since the composer map is square and the canvas may be
# arbitrarily shaped, we center based on the longest edge
canvas_extent = self.iface.mapCanvas().extent()
width = canvas_extent.width()
height = canvas_extent.height()
longest_length = width
if width < height:
longest_length = height
half_length = longest_length / 2
center = canvas_extent.center()
min_x = center.x() - half_length
max_x = center.x() + half_length
min_y = center.y() - half_length
max_y = center.y() + half_length
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
composer_map.setNewExtent(square_extent)
composer_map.setGridEnabled(True)
split_count = 5
# .. todo:: Write logic to adjust precision so that adjacent tick marks
# always have different displayed values
precision = 2
x_interval = composer_extent.width() / split_count
composer_map.setGridIntervalX(x_interval)
y_interval = composer_extent.height() / split_count
composer_map.setGridIntervalY(y_interval)
composer_map.setGridStyle(QgsComposerMap.Cross)
cross_length_mm = 1
composer_map.setCrossLength(cross_length_mm)
composer_map.setZValue(0) # To ensure it does not overlay logo
font_size = 6
font_weight = QtGui.QFont.Normal
italics_flag = False
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
composer_map.setGridAnnotationFont(font)
composer_map.setGridAnnotationPrecision(precision)
composer_map.setShowGridAnnotation(True)
composer_map.setGridAnnotationDirection(
QgsComposerMap.BoundaryDirection, QgsComposerMap.Top)
self.composition.addItem(composer_map)
self.draw_graticule_mask(top_offset)
return composer_map
def draw_graticule_mask(self, top_offset):
"""A helper function to mask out graticule labels.
It will hide labels on the right side by over painting a white
rectangle with white border on them. **kludge**
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawGraticuleMask called')
left_offset = self.page_margin + self.mapWidth
rect = QgsComposerShape(left_offset + 0.5, top_offset,
self.page_width - left_offset,
self.map_height + 1, self.composition)
rect.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setColor(QtGui.QColor(0, 0, 0))
pen.setWidthF(0.1)
rect.setPen(pen)
rect.setBackgroundColor(QtGui.QColor(255, 255, 255))
rect.setTransparency(100)
#rect.setLineWidth(0.1)
#rect.setFrameEnabled(False)
#rect.setOutlineColor(QtGui.QColor(255, 255, 255))
#rect.setFillColor(QtGui.QColor(255, 255, 255))
#rect.setOpacity(100)
# These two lines seem superfluous but are needed
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
rect.setBrush(brush)
self.composition.addItem(rect)
def draw_native_scalebar(self, composer_map, top_offset):
"""Draw a scale bar using QGIS' native drawing.
In the case of geographic maps, scale will be in degrees, not km.
:param composer_map: Composer map on which to draw the scalebar.
:type composer_map: QgsComposerMap
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawNativeScaleBar called')
scale_bar = QgsComposerScaleBar(self.composition)
scale_bar.setStyle('Numeric') # optionally modify the style
scale_bar.setComposerMap(composer_map)
scale_bar.applyDefaultSize()
scale_bar_height = scale_bar.boundingRect().height()
scale_bar_width = scale_bar.boundingRect().width()
# -1 to avoid overlapping the map border
scale_bar.setItemPosition(
self.page_margin + 1,
top_offset + self.map_height - (scale_bar_height * 2),
scale_bar_width, scale_bar_height)
scale_bar.setFrameEnabled(self.show_frames)
# Disabled for now
#self.composition.addItem(scale_bar)
def draw_scalebar(self, composer_map, top_offset):
"""Add a numeric scale to the bottom left of the map.
We draw the scale bar manually because QGIS does not yet support
rendering a scale bar for a geographic map in km.
.. seealso:: :meth:`drawNativeScaleBar`
:param composer_map: Composer map on which to draw the scalebar.
:type composer_map: QgsComposerMap
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawScaleBar called')
canvas = self.iface.mapCanvas()
renderer = canvas.mapRenderer()
#
# Add a linear map scale
#
distance_area = QgsDistanceArea()
distance_area.setSourceCrs(renderer.destinationCrs().srsid())
distance_area.setEllipsoidalMode(True)
# Determine how wide our map is in km/m
# Starting point at BL corner
composer_extent = composer_map.extent()
start_point = QgsPoint(composer_extent.xMinimum(),
composer_extent.yMinimum())
# Ending point at BR corner
end_point = QgsPoint(composer_extent.xMaximum(),
composer_extent.yMinimum())
ground_distance = distance_area.measureLine(start_point, end_point)
# Get the equivalent map distance per page mm
map_width = self.mapWidth
# How far is 1mm on map on the ground in meters?
mm_to_ground = ground_distance / map_width
#print 'MM:', myMMDistance
# How long we want the scale bar to be in relation to the map
scalebar_to_map_ratio = 0.5
# How many divisions the scale bar should have
tick_count = 5
scale_bar_width_mm = map_width * scalebar_to_map_ratio
print_segment_width_mm = scale_bar_width_mm / tick_count
# Segment width in real world (m)
# We apply some logic here so that segments are displayed in meters
# if each segment is less that 1000m otherwise km. Also the segment
# lengths are rounded down to human looking numbers e.g. 1km not 1.1km
units = ''
ground_segment_width = print_segment_width_mm * mm_to_ground
if ground_segment_width < 1000:
units = 'm'
ground_segment_width = round(ground_segment_width)
# adjust the segment width now to account for rounding
print_segment_width_mm = ground_segment_width / mm_to_ground
else:
units = 'km'
# Segment with in real world (km)
ground_segment_width = round(ground_segment_width / 1000)
print_segment_width_mm = ((ground_segment_width * 1000) /
mm_to_ground)
# Now adjust the scalebar width to account for rounding
scale_bar_width_mm = tick_count * print_segment_width_mm
#print "SBWMM:", scale_bar_width_mm
#print "SWMM:", print_segment_width_mm
#print "SWM:", myGroundSegmentWidthM
#print "SWKM:", myGroundSegmentWidthKM
# start drawing in line segments
scalebar_height = 5 # mm
line_width = 0.3 # mm
inset_distance = 7 # how much to inset the scalebar into the map by
scalebar_x = self.page_margin + inset_distance
scalebar_y = (top_offset + self.map_height - inset_distance -
scalebar_height) # mm
# Draw an outer background box - shamelessly hardcoded buffer
rectangle = QgsComposerShape(
scalebar_x - 4, # left edge
scalebar_y - 3, # top edge
scale_bar_width_mm + 13, # right edge
scalebar_height + 6, # bottom edge
self.composition)
rectangle.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setColor(QtGui.QColor(255, 255, 255))
pen.setWidthF(line_width)
rectangle.setPen(pen)
#rectangle.setLineWidth(line_width)
rectangle.setFrameEnabled(False)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
# workaround for missing setTransparentFill missing from python api
rectangle.setBrush(brush)
self.composition.addItem(rectangle)
# Set up the tick label font
font_weight = QtGui.QFont.Normal
font_size = 6
italics_flag = False
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
# Draw the bottom line
up_shift = 0.3 # shift the bottom line up for better rendering
rectangle = QgsComposerShape(scalebar_x,
scalebar_y + scalebar_height - up_shift,
scale_bar_width_mm, 0.1, self.composition)
rectangle.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setColor(QtGui.QColor(255, 255, 255))
pen.setWidthF(line_width)
rectangle.setPen(pen)
#rectangle.setLineWidth(line_width)
rectangle.setFrameEnabled(False)
self.composition.addItem(rectangle)
# Now draw the scalebar ticks
for tick_counter in range(0, tick_count + 1):
distance_suffix = ''
if tick_counter == tick_count:
distance_suffix = ' ' + units
real_world_distance = (
'%.0f%s' %
(tick_counter * ground_segment_width, distance_suffix))
#print 'RW:', myRealWorldDistance
mm_offset = scalebar_x + (tick_counter * print_segment_width_mm)
#print 'MM:', mm_offset
tick_height = scalebar_height / 2
# Lines are not exposed by the api yet so we
# bodge drawing lines using rectangles with 1px height or width
tick_width = 0.1 # width or rectangle to be drawn
uptick_line = QgsComposerShape(
mm_offset, scalebar_y + scalebar_height - tick_height,
tick_width, tick_height, self.composition)
uptick_line.setShapeType(QgsComposerShape.Rectangle)
pen = QtGui.QPen()
pen.setWidthF(line_width)
uptick_line.setPen(pen)
#uptick_line.setLineWidth(line_width)
uptick_line.setFrameEnabled(False)
self.composition.addItem(uptick_line)
#
# Add a tick label
#
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(real_world_distance)
label.adjustSizeToText()
label.setItemPosition(mm_offset - 3, scalebar_y - tick_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
def draw_impact_title(self, top_offset):
"""Draw the map subtitle - obtained from the impact layer keywords.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
:returns: The height of the label as rendered.
:rtype: float
"""
LOGGER.debug('InaSAFE Map drawImpactTitle called')
title = self.map_title()
if title is None:
title = ''
font_size = 20
font_weight = QtGui.QFont.Bold
italics_flag = False
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
heading = title
label.setText(heading)
label_width = self.page_width - (self.page_margin * 2)
label_height = 12
label.setItemPosition(self.page_margin, top_offset, label_width,
label_height)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
return label_height
def draw_legend(self, top_offset):
"""Add a legend to the map using our custom legend renderer.
.. note:: getLegend generates a pixmap in 150dpi so if you set
the map to a higher dpi it will appear undersized.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawLegend called')
legend_attributes = self.map_legend_attributes()
legend_notes = legend_attributes.get('legend_notes', None)
legend_units = legend_attributes.get('legend_units', None)
legend_title = legend_attributes.get('legend_title', None)
LOGGER.debug(legend_attributes)
legend = MapLegend(self.layer, self.page_dpi, legend_title,
legend_notes, legend_units)
self.legend = legend.get_legend()
picture1 = QgsComposerPicture(self.composition)
legend_file_path = unique_filename(prefix='legend',
suffix='.png',
dir='work')
self.legend.save(legend_file_path, 'PNG')
picture1.setPictureFile(legend_file_path)
legend_height = points_to_mm(self.legend.height(), self.page_dpi)
legend_width = points_to_mm(self.legend.width(), self.page_dpi)
picture1.setItemPosition(self.page_margin, top_offset, legend_width,
legend_height)
picture1.setFrameEnabled(False)
self.composition.addItem(picture1)
os.remove(legend_file_path)
def draw_image(self, image, width_mm, left_offset, top_offset):
"""Helper to draw an image directly onto the QGraphicsScene.
This is an alternative to using QgsComposerPicture which in
some cases leaves artifacts under windows.
The Pixmap will have a transform applied to it so that
it is rendered with the same resolution as the composition.
:param image: Image that will be rendered to the layout.
:type image: QImage
:param width_mm: Desired width in mm of output on page.
:type width_mm: int
:param left_offset: Offset from left of page.
:type left_offset: int
:param top_offset: Offset from top of page.
:type top_offset: int
:returns: Graphics scene item.
:rtype: QGraphicsSceneItem
"""
LOGGER.debug('InaSAFE Map drawImage called')
desired_width_mm = width_mm # mm
desired_width_px = mm_to_points(desired_width_mm, self.page_dpi)
actual_width_px = image.width()
scale_factor = desired_width_px / actual_width_px
LOGGER.debug('%s %s %s' %
(scale_factor, actual_width_px, desired_width_px))
transform = QtGui.QTransform()
transform.scale(scale_factor, scale_factor)
transform.rotate(0.5)
# noinspection PyArgumentList
item = self.composition.addPixmap(QtGui.QPixmap.fromImage(image))
item.setTransform(transform)
item.setOffset(left_offset / scale_factor, top_offset / scale_factor)
return item
def draw_host_and_time(self, top_offset):
"""Add a note with hostname and time to the composition.
:param top_offset: Vertical offset at which the logo should be drawn.
:type top_offset: int
"""
LOGGER.debug('InaSAFE Map drawDisclaimer called')
#elapsed_time: 11.612545
#user: timlinux
#host_name: ultrabook
#time_stamp: 2012-10-13_23:10:31
#myUser = self.keyword_io.readKeywords(self.layer, 'user')
#myHost = self.keyword_io.readKeywords(self.layer, 'host_name')
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
#myElapsedTime = self.keyword_io.readKeywords(self.layer,
# 'elapsed_time')
#myElapsedTime = humaniseSeconds(myElapsedTime)
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
label_text = self.tr(
'Date and time of assessment: %s %s\n'
'Special note: This assessment is a guide - we strongly recommend '
'that you ground truth the results shown here before deploying '
'resources and / or personnel.\n'
'Assessment carried out using InaSAFE release %s (QGIS '
'plugin version).') % (date, time, version)
font_size = 6
font_weight = QtGui.QFont.Normal
italics_flag = True
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(label_text)
label.adjustSizeToText()
label_height = 50.0 # mm determined using qgis map composer
label_width = (self.page_width / 2) - self.page_margin
left_offset = self.page_width / 2 # put in right half of page
label.setItemPosition(
left_offset,
top_offset,
label_width,
label_height,
)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
def draw_disclaimer(self):
"""Add a disclaimer to the composition."""
LOGGER.debug('InaSAFE Map drawDisclaimer called')
font_size = 10
font_weight = QtGui.QFont.Normal
italics_flag = True
font = QtGui.QFont('verdana', font_size, font_weight, italics_flag)
label = QgsComposerLabel(self.composition)
label.setFont(font)
label.setText(self.disclaimer)
label.adjustSizeToText()
label_height = 7.0 # mm determined using qgis map composer
label_width = self.page_width # item - position and size...option
left_offset = self.page_margin
top_offset = self.page_height - self.page_margin
label.setItemPosition(
left_offset,
top_offset,
label_width,
label_height,
)
label.setFrameEnabled(self.show_frames)
self.composition.addItem(label)
def map_title(self):
"""Get the map title from the layer keywords if possible.
:returns: None on error, otherwise the title.
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapTitle called')
try:
title = self.keyword_io.read_keywords(self.layer, 'map_title')
return title
except KeywordNotFoundError:
return None
except Exception:
return None
def map_legend_attributes(self):
"""Get the map legend attribute from the layer keywords if possible.
:returns: None on error, otherwise the attributes (notes and units).
:rtype: None, str
"""
LOGGER.debug('InaSAFE Map getMapLegendAtributes called')
legend_attribute_list = [
'legend_notes', 'legend_units', 'legend_title'
]
legend_attribute_dict = {}
for myLegendAttribute in legend_attribute_list:
try:
legend_attribute_dict[myLegendAttribute] = \
self.keyword_io.read_keywords(
self.layer, myLegendAttribute)
except KeywordNotFoundError:
pass
except Exception:
pass
return legend_attribute_dict
def show_composer(self):
"""Show the composition in a composer view so the user can tweak it.
"""
view = QgsComposerView(self.iface.mainWindow())
view.show()
def write_template(self, template_path):
"""Write current composition as a template that can be re-used in QGIS.
:param template_path: Path to which template should be written.
:type template_path: str
"""
document = QtXml.QDomDocument()
element = document.createElement('Composer')
document.appendChild(element)
self.composition.writeXML(element, document)
xml = document.toByteArray()
template_file = file(template_path, 'wb')
template_file.write(xml)
template_file.close()
def load_template(self):
"""Load a QgsComposer map from a template and render it.
.. note:: THIS METHOD IS EXPERIMENTAL
"""
self.setup_composition()
template_file = QtCore.QFile(self.template)
template_file.open(QtCore.QIODevice.ReadOnly | QtCore.QIODevice.Text)
template_content = template_file.readAll()
template_file.close()
document = QtXml.QDomDocument()
document.setContent(template_content)
# get information for substitutions
# date, time and plugin version
date_time = self.keyword_io.read_keywords(self.layer, 'time_stamp')
tokens = date_time.split('_')
date = tokens[0]
time = tokens[1]
long_version = get_version()
tokens = long_version.split('.')
version = '%s.%s.%s' % (tokens[0], tokens[1], tokens[2])
# map title
LOGGER.debug('InaSAFE Map getMapTitle called')
try:
title = self.keyword_io.read_keywords(self.layer, 'map_title')
except KeywordNotFoundError:
title = None
except Exception:
title = None
if not title:
title = ''
substitution_map = {
'impact-title': title,
'date': date,
'time': time,
'safe-version': version
}
LOGGER.debug(substitution_map)
load_ok = self.composition.loadFromTemplate(document, substitution_map)
if not load_ok:
raise ReportCreationError(
self.tr('Error loading template %s') % self.template)
self.page_width = self.composition.paperWidth()
self.page_height = self.composition.paperHeight()
# set logo
image = self.composition.getComposerItemById('safe-logo')
image.setPictureFile(self.logo)
# Get the main map canvas on the composition and set
# its extents to the event.
map = self.composition.getComposerItemById('impact-map')
if map is not None:
# Recenter the composer map on the center of the canvas
# Note that since the composer map is square and the canvas may be
# arbitrarily shaped, we center based on the longest edge
canvas_extent = self.iface.mapCanvas().extent()
width = canvas_extent.width()
height = canvas_extent.height()
longest_width = width
if width < height:
longest_width = height
half_length = longest_width / 2
center = canvas_extent.center()
min_x = center.x() - half_length
max_x = center.x() + half_length
min_y = center.y() - half_length
max_y = center.y() + half_length
square_extent = QgsRectangle(min_x, min_y, max_x, max_y)
map.setNewExtent(square_extent)
# calculate intervals for grid
split_count = 5
x_interval = square_extent.width() / split_count
map.setGridIntervalX(x_interval)
y_interval = square_extent.height() / split_count
map.setGridIntervalY(y_interval)
else:
raise ReportCreationError(
self.tr('Map "impact-map" could not be found'))
legend = self.composition.getComposerItemById('impact-legend')
legend_attributes = self.map_legend_attributes()
LOGGER.debug(legend_attributes)
#legend_notes = mapLegendAttributes.get('legend_notes', None)
#legend_units = mapLegendAttributes.get('legend_units', None)
legend_title = legend_attributes.get('legend_title', None)
if legend_title is None:
legend_title = ""
legend.setTitle(legend_title)
legend.updateLegend()
