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