def make_pdf():
canvas = QgsMapCanvas()
# Load our project
QgsProject.instance().read(QFileInfo(project_path))
bridge = QgsLayerTreeMapCanvasBridge(QgsProject.instance().layerTreeRoot(),
canvas)
bridge.setCanvasLayers()
template_file = file(template_path)
template_content = template_file.read()
template_file.close()
document = QDomDocument()
document.setContent(template_content)
composition = QgsComposition(canvas.mapSettings())
# You can use this to replace any string like this [key]
# in the template with a new value. e.g. to replace
# [date] pass a map like this {'date': '1 Jan 2012'}
substitution_map = {'DATE_TIME_START': 'foo', 'DATE_TIME_END': 'bar'}
composition.loadFromTemplate(document, substitution_map)
# You must set the id in the template
map_item = composition.getComposerItemById('map')
map_item.setMapCanvas(canvas)
map_item.zoomToExtent(canvas.extent())
# You must set the id in the template
legend_item = composition.getComposerItemById('legend')
legend_item.updateLegend()
composition.refreshItems()
composition.exportAsPDF('report.pdf')
QgsProject.instance().clear()
def make_pdf():
canvas = QgsMapCanvas()
# Load our project
QgsProject.instance().read(QFileInfo(project_path))
bridge = QgsLayerTreeMapCanvasBridge(
QgsProject.instance().layerTreeRoot(), canvas)
bridge.setCanvasLayers()
if canvas.layerCount() < 1:
print 'No layers loaded from this project, exiting.'
return
print canvas.mapSettings().extent().toString()
template_file = file(template_path)
template_content = template_file.read()
template_file.close()
document = QDomDocument()
document.setContent(template_content)
composition = QgsComposition(canvas.mapSettings())
# You can use this to replace any string like this [key]
# in the template with a new value. e.g. to replace
# [date] pass a map like this {'date': '1 Jan 2012'}
substitution_map = {
'DATE_TIME_START': TIME_START,
'DATE_TIME_END': TIME_STOP}
composition.loadFromTemplate(document, substitution_map)
# You must set the id in the template
map_item = composition.getComposerItemById('map')
map_item.setMapCanvas(canvas)
map_item.zoomToExtent(canvas.extent())
# You must set the id in the template
legend_item = composition.getComposerItemById('legend')
legend_item.updateLegend()
composition.refreshItems()
composition.exportAsPDF(
'/home/web/reports/pdf/%s/%s.pdf' % (TIME_SLICE, LABEL))
QgsProject.instance().clear()
def export_view(self):
'''
Export current view to PDF
'''
# Load template from file
s = QSettings()
f = s.value("cadastre/composerTemplateFile", '', type=str)
if not os.path.exists(f):
f = '%s/composers/paysage_a4.qpt' % os.path.dirname(__file__)
s.setValue("cadastre/composerTemplateFile", f)
QApplication.setOverrideCursor(Qt.WaitCursor)
tf = file(f, 'rt')
tc= tf.read()
tf.close()
d= QDomDocument()
d.setContent(tc)
# Create composition
ms = self.iface.mapCanvas().mapSettings()
c = QgsComposition(ms)
c.loadFromTemplate(d)
c.setPlotStyle(QgsComposition.Print)
#c.setPrintResolution(300)
# Set map
canvas = self.iface.mapCanvas()
cm = c.getComposerMapById(0)
extent = canvas.extent()
scale = canvas.scale()
cm.setMapCanvas(canvas)
if extent:
cm.zoomToExtent(extent)
if scale:
cm.setNewScale(scale)
# Export
tempDir = s.value("cadastre/tempDir", '%s' % tempfile.gettempdir(), type=str)
self.targetDir = tempfile.mkdtemp('', 'cad_export_', tempDir)
temp = int(time()*100)
temppath = os.path.join(tempDir, 'export_cadastre_%s.pdf' % temp)
c.exportAsPDF(temppath)
QApplication.restoreOverrideCursor()
if os.path.exists(temppath):
cadastre_common.openFile(temppath)
def export_pdf(self, title=''):
'''
Export Composition (map view and checked layers) to PDF
'''
title = self.active_scenario.name if self.active_scenario else ''
dialog = ExportPDFDialog(title=title, parent=self)
result = dialog.exec_()
ok = result == QtGui.QDialog.Accepted
if not ok:
return
title = dialog.title
date = dialog.date
filepath = browse_file(None, 'Export', PDF_FILTER, save=True,
parent=self)
if not filepath:
return
bridge = QgsLayerTreeMapCanvasBridge(
QgsProject.instance().layerTreeRoot(), self.canvas)
bridge.setCanvasLayers()
template_file = file(REPORT_TEMPLATE_PATH)
template_content = template_file.read()
template_file.close()
document = QDomDocument()
document.setContent(template_content)
composition = QgsComposition(self.canvas.mapSettings())
# You can use this to replace any string like this [key]
# in the template with a new value. e.g. to replace
# [date] pass a map like this {'date': '1 Jan 2012'}
substitution_map = {
'TITLE': title,
'DATE_TIME': date}
composition.loadFromTemplate(document, substitution_map)
# You must set the id in the template
map_item = composition.getComposerItemById('map')
map_item.setMapCanvas(self.canvas)
map_item.zoomToExtent(self.canvas.extent())
# You must set the id in the template
legend_item = composition.getComposerItemById('legend')
legend_item.updateLegend()
composition.refreshItems()
composition.exportAsPDF(filepath)
if sys.platform.startswith('darwin'):
subprocess.call(('open', filepath))
elif os.name == 'nt':
os.startfile(filepath)
elif os.name == 'posix':
subprocess.call(('xdg-open', filepath))
def printToPdf(self, params):
self.check_required_params(params)
with change_directory(self.project_root):
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(params.get('srs'))
mapRenderer = QgsMapRenderer()
mapUnits = crs.mapUnits()
mapRenderer.setMapUnits(mapUnits)
mapExtent = QgsRectangle(*params.get('bbox'))
mapRenderer.setExtent(mapExtent)
le = QgsPalLabeling()
mapRenderer.setLabelingEngine(le)
layers = params.get('layers')
self.setTransparencies(layers, params.get('transparencies'))
mapRenderer.setLayerSet(layers)
composer = (
self.getLayoutbyName(params['layout'])
.firstChildElement('Composition')
)
comp = QgsComposition(mapRenderer)
comp.setPlotStyle(QgsComposition.Print)
comp.readXML(composer, self.doc)
# read composition elements
comp.addItemsFromXML(composer, self.doc)
comp.setPrintResolution(90)
# set bbox for the first Map in the layout
comp_map = comp.getComposerMapById(0)
comp_map.setNewExtent(QgsRectangle(*params.get('bbox')))
# comp_map.setNewScale(10000)
# comp_map.setLayerSet(layers)
# comp_map.setKeepLayerSet(True)
# save the file
comp.exportAsPDF(params['tmpFile'] + '.pdf')
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 print_impact_table(self, output_path):
"""Pint summary from impact layer to PDF.
..note:: The order of the report:
1. Summary table
2. Aggregation table
3. Attribution table
:param output_path: Output path.
:type output_path: str
:return: Path to generated pdf file.
:rtype: str
:raises: None
"""
keywords = self._keyword_io.read_keywords(self.layer)
if output_path is None:
output_path = unique_filename(suffix='.pdf', dir=temp_dir())
summary_table = keywords.get('impact_summary', None)
full_table = keywords.get('impact_table', None)
aggregation_table = keywords.get('postprocessing_report', None)
attribution_table = impact_attribution(keywords)
# (AG) We will not use impact_table as most of the IF use that as:
# impact_table = impact_summary + some information intended to be
# shown on screen (see FloodOsmBuilding)
# Unless the impact_summary is None, we will use impact_table as the
# alternative
html = LOGO_ELEMENT.to_html()
html += m.Heading(tr('Analysis Results'), **INFO_STYLE).to_html()
if summary_table is None:
html += full_table
else:
html += summary_table
if aggregation_table is not None:
html += aggregation_table
if attribution_table is not None:
html += attribution_table.to_html()
html = html_header() + html + html_footer()
# Print HTML using composition
# For QGIS < 2.4 compatibility
# QgsMapSettings is added in 2.4
if qgis_version() < 20400:
map_settings = QgsMapRenderer()
else:
map_settings = QgsMapSettings()
# A4 Portrait
paper_width = 210
paper_height = 297
# noinspection PyCallingNonCallable
composition = QgsComposition(map_settings)
# noinspection PyUnresolvedReferences
composition.setPlotStyle(QgsComposition.Print)
composition.setPaperSize(paper_width, paper_height)
composition.setPrintResolution(300)
# Add HTML Frame
# noinspection PyCallingNonCallable
html_item = QgsComposerHtml(composition, False)
margin_left = 10
margin_top = 10
# noinspection PyCallingNonCallable
html_frame = QgsComposerFrame(
composition,
html_item,
margin_left,
margin_top,
paper_width - 2 * margin_left,
paper_height - 2 * margin_top)
html_item.addFrame(html_frame)
# Set HTML
# From QGIS 2.6, we can set composer HTML with manual HTML
if qgis_version() < 20600:
html_path = unique_filename(
prefix='report', suffix='.html', dir=temp_dir())
html_to_file(html, file_path=html_path)
html_url = QUrl.fromLocalFile(html_path)
html_item.setUrl(html_url)
else:
# noinspection PyUnresolvedReferences
html_item.setContentMode(QgsComposerHtml.ManualHtml)
# noinspection PyUnresolvedReferences
html_item.setResizeMode(QgsComposerHtml.RepeatUntilFinished)
html_item.setHtml(html)
html_item.loadHtml()
composition.exportAsPDF(output_path)
return output_path
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 generate_report(self):
# Generate pdf report from impact/hazard
LOGGER.info('Generating report')
if not self.impact_exists:
# Cannot generate report when no impact layer present
LOGGER.info('Cannot Generate report when no impact present.')
return
project_instance = QgsProject.instance()
project_instance.setFileName(self.project_path)
project_instance.read()
# get layer registry
layer_registry = QgsMapLayerRegistry.instance()
layer_registry.removeAllMapLayers()
# Set up the map renderer that will be assigned to the composition
map_renderer = CANVAS.mapRenderer()
# Enable on the fly CRS transformations
map_renderer.setProjectionsEnabled(True)
default_crs = map_renderer.destinationCrs()
crs = QgsCoordinateReferenceSystem('EPSG:4326')
map_renderer.setDestinationCrs(crs)
# add place name layer
layer_registry.addMapLayer(self.cities_layer, False)
# add airport layer
layer_registry.addMapLayer(self.airport_layer, False)
# add volcano layer
layer_registry.addMapLayer(self.volcano_layer, False)
# add impact layer
hazard_layer = read_qgis_layer(self.hazard_path,
self.tr('People Affected'))
layer_registry.addMapLayer(hazard_layer, False)
# add basemap layer
layer_registry.addMapLayer(self.highlight_base_layer, False)
# add basemap layer
layer_registry.addMapLayer(self.overview_layer, False)
CANVAS.setExtent(hazard_layer.extent())
CANVAS.refresh()
template_path = self.ash_fixtures_dir('realtime-ash.qpt')
with open(template_path) as f:
template_content = f.read()
document = QDomDocument()
document.setContent(template_content)
# Now set up the composition
# map_settings = QgsMapSettings()
# composition = QgsComposition(map_settings)
composition = QgsComposition(map_renderer)
subtitution_map = self.event_dict()
LOGGER.debug(subtitution_map)
# load composition object from template
result = composition.loadFromTemplate(document, subtitution_map)
if not result:
LOGGER.exception('Error loading template %s with keywords\n %s',
template_path, subtitution_map)
raise MapComposerError
# get main map canvas on the composition and set extent
map_impact = composition.getComposerItemById('map-impact')
if map_impact:
map_impact.zoomToExtent(hazard_layer.extent())
map_impact.renderModeUpdateCachedImage()
else:
LOGGER.exception('Map canvas could not be found in template %s',
template_path)
raise MapComposerError
# get overview map canvas on the composition and set extent
map_overall = composition.getComposerItemById('map-overall')
if map_overall:
map_overall.setLayerSet([self.overview_layer.id()])
# this is indonesia extent
indonesia_extent = QgsRectangle(94.0927980005593554,
-15.6629591962689343,
142.0261493318861312,
10.7379406374101816)
map_overall.zoomToExtent(indonesia_extent)
map_overall.renderModeUpdateCachedImage()
else:
LOGGER.exception('Map canvas could not be found in template %s',
template_path)
raise MapComposerError
# setup impact table
self.render_population_table()
self.render_nearby_table()
self.render_landcover_table()
impact_table = composition.getComposerItemById('table-impact')
if impact_table is None:
message = 'table-impact composer item could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
impacts_html = composition.getComposerHtmlByItem(impact_table)
if impacts_html is None:
message = 'Impacts QgsComposerHtml could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
impacts_html.setUrl(QUrl(self.population_html_path))
# setup nearby table
nearby_table = composition.getComposerItemById('table-nearby')
if nearby_table is None:
message = 'table-nearby composer item could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
nearby_html = composition.getComposerHtmlByItem(nearby_table)
if nearby_html is None:
message = 'Nearby QgsComposerHtml could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
nearby_html.setUrl(QUrl(self.nearby_html_path))
# setup landcover table
landcover_table = composition.getComposerItemById('table-landcover')
if landcover_table is None:
message = 'table-landcover composer item could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
landcover_html = composition.getComposerHtmlByItem(landcover_table)
if landcover_html is None:
message = 'Landcover QgsComposerHtml could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
landcover_html.setUrl(QUrl(self.landcover_html_path))
# setup logos
logos_id = ['logo-bnpb', 'logo-geologi']
for logo_id in logos_id:
logo_picture = composition.getComposerItemById(logo_id)
if logo_picture is None:
message = '%s composer item could not be found' % logo_id
LOGGER.exception(message)
raise MapComposerError(message)
pic_path = os.path.basename(logo_picture.picturePath())
pic_path = os.path.join('logo', pic_path)
logo_picture.setPicturePath(self.ash_fixtures_dir(pic_path))
# save a pdf
composition.exportAsPDF(self.map_report_path)
project_instance.write(QFileInfo(self.project_path))
layer_registry.removeAllMapLayers()
map_renderer.setDestinationCrs(default_crs)
map_renderer.setProjectionsEnabled(False)
LOGGER.info('Report generation completed.')
def print_impact_table(self, output_path):
"""Pint summary from impact layer to PDF.
..note:: The order of the report:
1. Summary table
2. Aggregation table
3. Attribution table
:param output_path: Output path.
:type output_path: str
:return: Path to generated pdf file.
:rtype: str
:raises: None
"""
keywords = self._keyword_io.read_keywords(self.layer)
if output_path is None:
output_path = unique_filename(suffix='.pdf', dir=temp_dir())
try:
impact_template = get_report_template(self.layer.source())
summary_table = impact_template.generate_html_report()
except:
summary_table = keywords.get('impact_summary', None)
full_table = keywords.get('impact_table', None)
aggregation_table = keywords.get('postprocessing_report', None)
attribution_table = impact_attribution(keywords)
# (AG) We will not use impact_table as most of the IF use that as:
# impact_table = impact_summary + some information intended to be
# shown on screen (see FloodOsmBuilding)
# Unless the impact_summary is None, we will use impact_table as the
# alternative
html = m.Brand().to_html()
html += m.Heading(tr('Analysis Results'), **INFO_STYLE).to_html()
if summary_table is None:
html += full_table
else:
html += summary_table
if aggregation_table is not None:
html += aggregation_table
if attribution_table is not None:
html += attribution_table.to_html()
html = html_header() + html + html_footer()
# Print HTML using composition
# For QGIS < 2.4 compatibility
# QgsMapSettings is added in 2.4
if qgis_version() < 20400:
map_settings = QgsMapRenderer()
else:
map_settings = QgsMapSettings()
# A4 Portrait
# TODO: Will break when we try to use larger print layouts TS
paper_width = 210
paper_height = 297
# noinspection PyCallingNonCallable
composition = QgsComposition(map_settings)
# noinspection PyUnresolvedReferences
composition.setPlotStyle(QgsComposition.Print)
composition.setPaperSize(paper_width, paper_height)
composition.setPrintResolution(300)
# Add HTML Frame
# noinspection PyCallingNonCallable
html_item = QgsComposerHtml(composition, False)
margin_left = 10
margin_top = 10
# noinspection PyCallingNonCallable
html_frame = QgsComposerFrame(
composition,
html_item,
margin_left,
margin_top,
paper_width - 2 * margin_left,
paper_height - 2 * margin_top)
html_item.addFrame(html_frame)
# Set HTML
# From QGIS 2.6, we can set composer HTML with manual HTML
if qgis_version() < 20600:
html_path = unique_filename(
prefix='report', suffix='.html', dir=temp_dir())
html_to_file(html, file_path=html_path)
html_url = QUrl.fromLocalFile(html_path)
html_item.setUrl(html_url)
else:
# noinspection PyUnresolvedReferences
html_item.setContentMode(QgsComposerHtml.ManualHtml)
# noinspection PyUnresolvedReferences
html_item.setResizeMode(QgsComposerHtml.RepeatUntilFinished)
html_item.setHtml(html)
# RMN: This line below breaks in InaSAFE Headless after one
# successful call. This is because the function is not
# thread safe. Can't do anything about this, so avoid calling this
# function in multithreaded way.
html_item.loadHtml()
composition.exportAsPDF(output_path)
return output_path
def generate_report(self):
# Generate pdf report from impact/hazard
LOGGER.info("Generating report")
if not self.impact_exists:
# Cannot generate report when no impact layer present
LOGGER.info("Cannot Generate report when no impact present.")
return
project_instance = QgsProject.instance()
project_instance.setFileName(self.project_path)
project_instance.read()
# get layer registry
layer_registry = QgsMapLayerRegistry.instance()
layer_registry.removeAllMapLayers()
# Set up the map renderer that will be assigned to the composition
map_renderer = CANVAS.mapRenderer()
# Enable on the fly CRS transformations
map_renderer.setProjectionsEnabled(True)
default_crs = map_renderer.destinationCrs()
crs = QgsCoordinateReferenceSystem("EPSG:4326")
map_renderer.setDestinationCrs(crs)
# add place name layer
layer_registry.addMapLayer(self.cities_layer, False)
# add airport layer
layer_registry.addMapLayer(self.airport_layer, False)
# add volcano layer
layer_registry.addMapLayer(self.volcano_layer, False)
# add impact layer
hazard_layer = read_qgis_layer(self.hazard_path, self.tr("People Affected"))
layer_registry.addMapLayer(hazard_layer, False)
# add basemap layer
layer_registry.addMapLayer(self.highlight_base_layer, False)
# add basemap layer
layer_registry.addMapLayer(self.overview_layer, False)
CANVAS.setExtent(hazard_layer.extent())
CANVAS.refresh()
template_path = self.ash_fixtures_dir("realtime-ash.qpt")
with open(template_path) as f:
template_content = f.read()
document = QDomDocument()
document.setContent(template_content)
# Now set up the composition
# map_settings = QgsMapSettings()
# composition = QgsComposition(map_settings)
composition = QgsComposition(map_renderer)
subtitution_map = self.event_dict()
LOGGER.debug(subtitution_map)
# load composition object from template
result = composition.loadFromTemplate(document, subtitution_map)
if not result:
LOGGER.exception("Error loading template %s with keywords\n %s", template_path, subtitution_map)
raise MapComposerError
# get main map canvas on the composition and set extent
map_impact = composition.getComposerItemById("map-impact")
if map_impact:
map_impact.zoomToExtent(hazard_layer.extent())
map_impact.renderModeUpdateCachedImage()
else:
LOGGER.exception("Map canvas could not be found in template %s", template_path)
raise MapComposerError
# get overview map canvas on the composition and set extent
map_overall = composition.getComposerItemById("map-overall")
if map_overall:
map_overall.setLayerSet([self.overview_layer.id()])
# this is indonesia extent
indonesia_extent = QgsRectangle(
94.0927980005593554, -15.6629591962689343, 142.0261493318861312, 10.7379406374101816
)
map_overall.zoomToExtent(indonesia_extent)
map_overall.renderModeUpdateCachedImage()
else:
LOGGER.exception("Map canvas could not be found in template %s", template_path)
raise MapComposerError
# setup impact table
self.render_population_table()
self.render_nearby_table()
self.render_landcover_table()
impact_table = composition.getComposerItemById("table-impact")
if impact_table is None:
message = "table-impact composer item could not be found"
LOGGER.exception(message)
raise MapComposerError(message)
impacts_html = composition.getComposerHtmlByItem(impact_table)
if impacts_html is None:
message = "Impacts QgsComposerHtml could not be found"
LOGGER.exception(message)
raise MapComposerError(message)
impacts_html.setUrl(QUrl(self.population_html_path))
# setup nearby table
nearby_table = composition.getComposerItemById("table-nearby")
if nearby_table is None:
message = "table-nearby composer item could not be found"
LOGGER.exception(message)
raise MapComposerError(message)
nearby_html = composition.getComposerHtmlByItem(nearby_table)
if nearby_html is None:
message = "Nearby QgsComposerHtml could not be found"
LOGGER.exception(message)
raise MapComposerError(message)
nearby_html.setUrl(QUrl(self.nearby_html_path))
# setup landcover table
landcover_table = composition.getComposerItemById("table-landcover")
if landcover_table is None:
message = "table-landcover composer item could not be found"
LOGGER.exception(message)
raise MapComposerError(message)
landcover_html = composition.getComposerHtmlByItem(landcover_table)
if landcover_html is None:
message = "Landcover QgsComposerHtml could not be found"
LOGGER.exception(message)
raise MapComposerError(message)
landcover_html.setUrl(QUrl(self.landcover_html_path))
# setup logos
logos_id = ["logo-bnpb", "logo-geologi"]
for logo_id in logos_id:
logo_picture = composition.getComposerItemById(logo_id)
if logo_picture is None:
message = "%s composer item could not be found" % logo_id
LOGGER.exception(message)
raise MapComposerError(message)
pic_path = os.path.basename(logo_picture.picturePath())
pic_path = os.path.join("logo", pic_path)
logo_picture.setPicturePath(self.ash_fixtures_dir(pic_path))
# save a pdf
composition.exportAsPDF(self.map_report_path)
project_instance.write(QFileInfo(self.project_path))
layer_registry.removeAllMapLayers()
map_renderer.setDestinationCrs(default_crs)
map_renderer.setProjectionsEnabled(False)
LOGGER.info("Report generation completed.")
def print_atlas(self,
project_path,
composer_name,
predefined_scales,
feature_filter=None,
page_name_expression=None):
if not feature_filter:
QgsMessageLog.logMessage(
"atlasprint: NO feature_filter provided !")
return None
# Get composer from project
# in QGIS 2, canno get composers without iface
# so we reading project xml and extract composer
# in QGIS 3.0, we will use project layoutManager()
from xml.etree import ElementTree as ET
composer_xml = None
with open(project_path, 'r') as f:
tree = ET.parse(f)
for elem in tree.findall('.//Composer[@title="%s"]' %
composer_name):
composer_xml = ET.tostring(elem, encoding='utf8', method='xml')
if not composer_xml:
QgsMessageLog.logMessage("atlasprint: Composer XML not parsed !")
return None
document = QDomDocument()
document.setContent(composer_xml)
# Get canvas, map setting & instantiate composition
canvas = QgsMapCanvas()
QgsProject.instance().read(QFileInfo(project_path))
bridge = QgsLayerTreeMapCanvasBridge(
QgsProject.instance().layerTreeRoot(), canvas)
bridge.setCanvasLayers()
ms = canvas.mapSettings()
composition = QgsComposition(ms)
# Load content from XML
substitution_map = {}
composition.loadFromTemplate(document, substitution_map)
# Get atlas for this composition
atlas = composition.atlasComposition()
atlas.setEnabled(True)
atlas_map = composition.getComposerMapById(0)
atlas_map.setAtlasScalingMode(QgsComposerMap.Predefined)
# get project scales
atlas.setPredefinedScales(predefined_scales)
atlas_map.setAtlasDriven(True)
#atlas.setComposerMap(atlas_map)
if page_name_expression:
atlas.setPageNameExpression(page_name_expression)
# Filter feature here to avoid QGIS looping through every feature when doing : composition.setAtlasMode(QgsComposition.ExportAtlas)
coverageLayer = atlas.coverageLayer()
# Filter by FID as QGIS cannot compile expressions with $id or other $ vars
# which leads to bad perfs for big datasets
useFid = None
if '$id' in feature_filter:
import re
ids = map(int, re.findall(r'\d+', feature_filter))
if len(ids) > 0:
useFid = ids[0]
if useFid:
qReq = QgsFeatureRequest().setFilterFid(useFid)
else:
qReq = QgsFeatureRequest().setFilterExpression(feature_filter)
# Change feature_filter in order to improve perfs
pks = coverageLayer.dataProvider().pkAttributeIndexes()
if useFid and len(pks) == 1:
pk = coverageLayer.dataProvider().fields()[pks[0]].name()
feature_filter = '"%s" IN (%s)' % (pk, useFid)
QgsMessageLog.logMessage(
"atlasprint: feature_filter changed into: %s" % feature_filter)
qReq = QgsFeatureRequest().setFilterExpression(feature_filter)
atlas.setFilterFeatures(True)
atlas.setFeatureFilter(feature_filter)
uid = uuid4()
i = 0
# Set Atlas mode
composition.setAtlasMode(QgsComposition.ExportAtlas)
atlas.beginRender()
for feat in coverageLayer.getFeatures(qReq):
atlas.prepareForFeature(feat)
export_path = os.path.join(
tempfile.gettempdir(),
'%s_%s.pdf' % (atlas.nameForPage(i), uid))
exported = composition.exportAsPDF(export_path)
if not exported or not os.path.isfile(export_path):
QgsMessageLog.logMessage(
"atlasprint: An error occured while exporting the atlas !")
return None
break
atlas.endRender()
if os.path.isfile(export_path):
QgsMessageLog.logMessage("atlasprint: path generated %s" %
export_path)
return export_path
{
"selector": ", table",
"props": [("border-collapse", "collapse"), ("border-spacing", "0")],
},
{"selector": ", th, td", "props": [("border", "1px solid black")]},
{"selector": ", td", "props": [("text-align", "right")]},
{"selector": ", th", "props": [("text-align", "center")]},
]
).render()
stats_table.setHtml(html)
stats_table.loadHtml()
region_name = atlas.feature().attribute("aoi_name")
title_label.setText(title_text.replace("%REGION_NAME%", region_name))
description = description_text.replace("%REGION_NAME%", region_name)
description = description.replace("%REF_PERIOD%", reference_period)
description = description.replace("%TARGET_PERIOD%", str(period))
description_label.setText(description)
filename = (
os.path.splitext(report_pdf_file)[0]
+ "_"
+ region_id
+ os.path.splitext(report_pdf_file)[1]
)
composition.exportAsPDF(filename)
atlas.endRender()
# The two lines below should reset the vector style to the original but they crash QGIS so for
# now they are commented out.
# vector_layer.setRendererV2(original_renderer)
# vector_layer.triggerRepaint()
def generate_report(self):
# Generate pdf report from impact/hazard
if not self.impact_exists:
# Cannot generate report when no impact layer present
return
project_path = os.path.join(self.report_path,
'project-%s.qgs' % self.locale)
project_instance = QgsProject.instance()
project_instance.setFileName(project_path)
project_instance.read()
# Set up the map renderer that will be assigned to the composition
map_renderer = CANVAS.mapRenderer()
# Set the labelling engine for the canvas
labelling_engine = QgsPalLabeling()
map_renderer.setLabelingEngine(labelling_engine)
# Enable on the fly CRS transformations
map_renderer.setProjectionsEnabled(True)
default_crs = map_renderer.destinationCrs()
crs = QgsCoordinateReferenceSystem('EPSG:4326')
map_renderer.setDestinationCrs(crs)
# get layer registry
layer_registry = QgsMapLayerRegistry.instance()
layer_registry.removeAllMapLayers()
# add impact layer
population_affected_layer = read_qgis_layer(
self.population_aggregate_path, self.tr('People Affected'))
layer_registry.addMapLayer(population_affected_layer, True)
# add boundary mask
boundary_mask = read_qgis_layer(
self.flood_fixtures_dir('boundary-mask.shp'))
layer_registry.addMapLayer(boundary_mask, False)
# add hazard layer
hazard_layer = read_qgis_layer(self.hazard_path,
self.tr('Flood Depth (cm)'))
layer_registry.addMapLayer(hazard_layer, True)
# add boundary layer
boundary_layer = read_qgis_layer(
self.flood_fixtures_dir('boundary-5.shp'))
layer_registry.addMapLayer(boundary_layer, False)
CANVAS.setExtent(boundary_layer.extent())
CANVAS.refresh()
# add basemap layer
# this code uses OpenlayersPlugin
base_map = QgsRasterLayer(self.flood_fixtures_dir('jakarta.jpg'))
layer_registry.addMapLayer(base_map, False)
CANVAS.refresh()
template_path = self.flood_fixtures_dir('realtime-flood.qpt')
with open(template_path) as f:
template_content = f.read()
document = QDomDocument()
document.setContent(template_content)
# set destination CRS to Jakarta CRS
# EPSG:32748
# This allows us to use the scalebar in meter unit scale
crs = QgsCoordinateReferenceSystem('EPSG:32748')
map_renderer.setDestinationCrs(crs)
# Now set up the composition
composition = QgsComposition(map_renderer)
subtitution_map = self.event_dict()
LOGGER.debug(subtitution_map)
# load composition object from template
result = composition.loadFromTemplate(document, subtitution_map)
if not result:
LOGGER.exception('Error loading template %s with keywords\n %s',
template_path, subtitution_map)
raise MapComposerError
# get main map canvas on the composition and set extent
map_canvas = composition.getComposerItemById('map-canvas')
if map_canvas:
map_canvas.setNewExtent(map_canvas.currentMapExtent())
map_canvas.renderModeUpdateCachedImage()
else:
LOGGER.exception('Map canvas could not be found in template %s',
template_path)
raise MapComposerError
# get map legend on the composition
map_legend = composition.getComposerItemById('map-legend')
if map_legend:
# show only legend for Flood Depth
# ''.star
# showed_legend = [layer_id for layer_id in map_renderer.layerSet()
# if layer_id.startswith('Flood_Depth')]
# LOGGER.info(showed_legend)
# LOGGER.info(map_renderer.layerSet())
# LOGGER.info(hazard_layer.id())
# map_legend.model().setLayerSet(showed_legend)
# map_legend.modelV2().clear()
# print dir(map_legend.modelV2())
# map_legend.setLegendFilterByMapEnabled(True)
map_legend.model().setLayerSet(
[hazard_layer.id(),
population_affected_layer.id()])
else:
LOGGER.exception('Map legend could not be found in template %s',
template_path)
raise MapComposerError
content_analysis = composition.getComposerItemById(
'content-analysis-result')
if not content_analysis:
message = 'Content analysis composer item could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
content_analysis_html = content_analysis.multiFrame()
if content_analysis_html:
# set url to generated html
analysis_html_path = self.generate_analysis_result_html()
# We're using manual HTML to avoid memory leak and segfault
# happened when using Url Mode
content_analysis_html.setContentMode(QgsComposerHtml.ManualHtml)
with open(analysis_html_path) as f:
content_analysis_html.setHtml(f.read())
content_analysis_html.loadHtml()
else:
message = 'Content analysis HTML not found in template'
LOGGER.exception(message)
raise MapComposerError(message)
# save a pdf
composition.exportAsPDF(self.map_report_path)
project_instance.write(QFileInfo(project_path))
layer_registry.removeAllMapLayers()
map_renderer.setDestinationCrs(default_crs)
map_renderer.setProjectionsEnabled(False)
def generate_report(self):
# Generate pdf report from impact/hazard
if not self.impact_exists:
# Cannot generate report when no impact layer present
return
project_path = os.path.join(
self.report_path, 'project-%s.qgs' % self.locale)
project_instance = QgsProject.instance()
project_instance.setFileName(project_path)
project_instance.read()
# Set up the map renderer that will be assigned to the composition
map_renderer = CANVAS.mapRenderer()
# Set the labelling engine for the canvas
labelling_engine = QgsPalLabeling()
map_renderer.setLabelingEngine(labelling_engine)
# Enable on the fly CRS transformations
map_renderer.setProjectionsEnabled(True)
default_crs = map_renderer.destinationCrs()
crs = QgsCoordinateReferenceSystem('EPSG:4326')
map_renderer.setDestinationCrs(crs)
# get layer registry
layer_registry = QgsMapLayerRegistry.instance()
layer_registry.removeAllMapLayers()
# add impact layer
population_affected_layer = read_qgis_layer(
self.population_aggregate_path, self.tr('People Affected'))
layer_registry.addMapLayer(population_affected_layer, True)
# add boundary mask
boundary_mask = read_qgis_layer(
self.flood_fixtures_dir('boundary-mask.shp'))
layer_registry.addMapLayer(boundary_mask, False)
# add hazard layer
hazard_layer = read_qgis_layer(
self.hazard_path, self.tr('Flood Depth (cm)'))
layer_registry.addMapLayer(hazard_layer, True)
# add boundary layer
boundary_layer = read_qgis_layer(
self.flood_fixtures_dir('boundary-5.shp'))
layer_registry.addMapLayer(boundary_layer, False)
CANVAS.setExtent(boundary_layer.extent())
CANVAS.refresh()
# add basemap layer
# this code uses OpenlayersPlugin
base_map = QgsRasterLayer(
self.flood_fixtures_dir('jakarta.jpg'))
layer_registry.addMapLayer(base_map, False)
CANVAS.refresh()
template_path = self.flood_fixtures_dir('realtime-flood.qpt')
with open(template_path) as f:
template_content = f.read()
document = QDomDocument()
document.setContent(template_content)
# set destination CRS to Jakarta CRS
# EPSG:32748
# This allows us to use the scalebar in meter unit scale
crs = QgsCoordinateReferenceSystem('EPSG:32748')
map_renderer.setDestinationCrs(crs)
# Now set up the composition
composition = QgsComposition(map_renderer)
subtitution_map = self.event_dict()
LOGGER.debug(subtitution_map)
# load composition object from template
result = composition.loadFromTemplate(document, subtitution_map)
if not result:
LOGGER.exception(
'Error loading template %s with keywords\n %s',
template_path, subtitution_map)
raise MapComposerError
# get main map canvas on the composition and set extent
map_canvas = composition.getComposerItemById('map-canvas')
if map_canvas:
map_canvas.setNewExtent(map_canvas.currentMapExtent())
map_canvas.renderModeUpdateCachedImage()
else:
LOGGER.exception('Map canvas could not be found in template %s',
template_path)
raise MapComposerError
# get map legend on the composition
map_legend = composition.getComposerItemById('map-legend')
if map_legend:
# show only legend for Flood Depth
# ''.star
# showed_legend = [layer_id for layer_id in map_renderer.layerSet()
# if layer_id.startswith('Flood_Depth')]
# LOGGER.info(showed_legend)
# LOGGER.info(map_renderer.layerSet())
# LOGGER.info(hazard_layer.id())
# map_legend.model().setLayerSet(showed_legend)
# map_legend.modelV2().clear()
# print dir(map_legend.modelV2())
# map_legend.setLegendFilterByMapEnabled(True)
map_legend.model().setLayerSet(
[hazard_layer.id(), population_affected_layer.id()])
else:
LOGGER.exception('Map legend could not be found in template %s',
template_path)
raise MapComposerError
content_analysis = composition.getComposerItemById(
'content-analysis-result')
if not content_analysis:
message = 'Content analysis composer item could not be found'
LOGGER.exception(message)
raise MapComposerError(message)
content_analysis_html = content_analysis.multiFrame()
if content_analysis_html:
# set url to generated html
analysis_html_path = self.generate_analysis_result_html()
# We're using manual HTML to avoid memory leak and segfault
# happened when using Url Mode
content_analysis_html.setContentMode(QgsComposerHtml.ManualHtml)
with open(analysis_html_path) as f:
content_analysis_html.setHtml(f.read())
content_analysis_html.loadHtml()
else:
message = 'Content analysis HTML not found in template'
LOGGER.exception(message)
raise MapComposerError(message)
# save a pdf
composition.exportAsPDF(self.map_report_path)
project_instance.write(QFileInfo(project_path))
layer_registry.removeAllMapLayers()
map_renderer.setDestinationCrs(default_crs)
map_renderer.setProjectionsEnabled(False)
def exportToPdf(self, print_context, targetFile=None):
self.iface.mapCanvas().setDestinationCrs(
self.settings_instance.projection.crs())
myComposition = QgsComposition(self.iface.mapCanvas().mapSettings())
template = self.env.get_template(print_context['template'])
custom_qpt = template.render(CONTEXT=print_context)
myDocument = QDomDocument()
myDocument.setContent(custom_qpt)
myComposition.loadFromTemplate(myDocument)
suggestedFile = os.path.join(
self.settings_instance.projectFolderPath.text(),
print_context['title'] + ".pdf")
if not targetFile:
targetFile = QFileDialog.getSaveFileName(
None, "Export " + print_context['job'], suggestedFile, "*.pdf")
interactive = True
if not targetFile:
return
else:
interactive = None
outputDir = tempfile.gettempdir()
with open(os.path.join(targetFile + '.qpt'), "wb") as qpt_file:
qpt_file.write(custom_qpt)
if print_context['type'] == 'report':
myComposition.exportAsPDF(targetFile)
elif print_context['type'] == 'map':
print myComposition.getComposerMapById(0)
print myComposition.getComposerItemById('5')
for composer_map in myComposition.composerMapItems():
print composer_map, composer_map.id()
fdtm_extent = None
for layer in [
self.settings_instance.EPpLayer,
self.settings_instance.EApLayer,
self.settings_instance.WRLayer,
self.settings_instance.WDSLayer
]:
if layer.featureCount() > 0:
if fdtm_extent:
fdtm_extent.combineExtentWith(layer.extent())
else:
fdtm_extent = layer.extent()
fdtm_extent.scale(1.1)
composer_map.zoomToExtent(fdtm_extent)
composer_map.updateItem()
myComposition.refreshItems()
myComposition.exportAsPDF(targetFile)
elif print_context['type'] == 'mapppp':
print print_context
myComposition = QgsComposition(
self.iface.mapCanvas().mapSettings())
myComposition.setPlotStyle(QgsComposition.Print)
myComposition.setPaperSize(297, 210)
composer_map = QgsComposerMap(myComposition, 10, 10, 190, 190)
fdtm_extent = self.settings_instance.EPpLayer.extent()
for layer in [
self.settings_instance.EApLayer,
self.settings_instance.WRLayer,
self.settings_instance.WDSLayer
]:
fdtm_extent.combineExtentWith(layer.extent())
composer_map.zoomToExtent(fdtm_extent)
composer_map.updateItem()
myComposition.addItem(composer_map)
table = QgsComposerAttributeTable(myComposition)
table.setItemPosition(205, 170)
table.setVectorLayer(QgsMapLayerRegistry.instance().mapLayer(
print_context['id']))
table.setMaximumNumberOfFeatures(20)
table.setFilterFeatures(True)
col1 = QgsComposerTableColumn()
col1.setAttribute('types')
col1.setHeading("types")
col2 = QgsComposerTableColumn()
col2.setAttribute('project units')
col2.setHeading("project units")
col3 = QgsComposerTableColumn()
col3.setAttribute('Areas')
col3.setHeading("Areas")
col4 = QgsComposerTableColumn()
col4.setAttribute('Lengths')
col4.setHeading("Lengths")
col5 = QgsComposerTableColumn()
col5.setAttribute('Cost')
col5.setHeading("Cost")
table.setColumns([col1, col2, col3, col4, col5])
myComposition.addItem(table)
myComposition.exportAsPDF(targetFile)
elif print_context['type'] == 'atlas':
myComposition.setAtlasMode(QgsComposition.ExportAtlas)
for composer_map in myComposition.composerMapItems():
print composer_map, composer_map.id()
atlas = myComposition.atlasComposition()
atlas.setComposerMap(composer_map) #DEPRECATED
atlas.setPredefinedScales(self.PREDEFINED_SCALES)
composer_map.setAtlasDriven(True)
composer_map.setAtlasScalingMode(QgsComposerMap.Predefined)
atlas.beginRender()
rendered_pdf = []
progress = progressBar(self, "exporting " + print_context['job'],
atlas.numFeatures())
for i in range(0, atlas.numFeatures()):
atlas.prepareForFeature(i)
current_filename = atlas.currentFilename()
file_name = '_'.join(current_filename.split())
file_path = '%s.pdf' % file_name
path = os.path.join(outputDir, file_path)
myComposition.exportAsPDF(path)
rendered_pdf.append(path)
progress.setStep(i)
progress.stop(print_context['job'] + "exported to " + targetFile)
atlas.endRender()
merge_pdfs(rendered_pdf, targetFile)
if interactive:
open_file(targetFile)
return targetFile
def print_atlas(self,
project_path,
composer_name,
predefined_scales,
feature_filter=None,
page_name_expression=None):
# Get composer from project
# in QGIS 2, canno get composers without iface
# so we reading project xml and extract composer
# in QGIS 3.0, we will use project layoutManager()
from xml.etree import ElementTree as ET
composer_xml = None
with open(project_path, 'r') as f:
tree = ET.parse(f)
for elem in tree.findall('.//Composer[@title="%s"]' %
composer_name):
composer_xml = ET.tostring(elem, encoding='utf8', method='xml')
if not composer_xml:
return
document = QDomDocument()
document.setContent(composer_xml)
# Get canvas, map setting & instantiate composition
canvas = QgsMapCanvas()
QgsProject.instance().read(QFileInfo(project_path))
bridge = QgsLayerTreeMapCanvasBridge(
QgsProject.instance().layerTreeRoot(), canvas)
bridge.setCanvasLayers()
ms = canvas.mapSettings()
composition = QgsComposition(ms)
# Load content from XML
substitution_map = {}
composition.loadFromTemplate(document, substitution_map)
# Get atlas for this composition
atlas = composition.atlasComposition()
atlas.setEnabled(True)
atlas_map = composition.getComposerMapById(0)
atlas_map.setAtlasScalingMode(QgsComposerMap.Predefined)
# get project scales
atlas.setPredefinedScales(predefined_scales)
atlas.setComposerMap(atlas_map)
#on definit le filtre
if feature_filter:
atlas.setFilterFeatures(True)
atlas.setFeatureFilter(feature_filter)
if page_name_expression:
atlas.setPageNameExpression(page_name_expression)
# Set atlas mode
composition.setAtlasMode(QgsComposition.ExportAtlas)
# Generate atlas
atlas.beginRender()
uid = uuid4()
for i in range(0, atlas.numFeatures()):
atlas.prepareForFeature(i)
export_path = os.path.join(
tempfile.gettempdir(),
'%s_%s.pdf' % (atlas.nameForPage(i), uid))
exported = composition.exportAsPDF(export_path)
if not exported or not os.path.isfile(export_path):
return None
break
atlas.endRender()
return export_path
