def __export(self):
settings = QSettings()
format = self.dialogui.comboBox_fileformat.itemData(
self.dialogui.comboBox_fileformat.currentIndex())
filepath = QFileDialog.getSaveFileName(
self.iface.mainWindow(), self.tr("Export Layout"),
settings.value("/instantprint/lastfile", ""), format)
if not all(filepath):
return
# Ensure output filename has correct extension
filename = os.path.splitext(
filepath[0]
)[0] + "." + self.dialogui.comboBox_fileformat.currentText().lower()
settings.setValue("/instantprint/lastfile", filepath[0])
if self.populateCompositionFz:
self.populateCompositionFz(self.layoutView.composition())
success = False
layout_name = self.dialogui.comboBox_layouts.currentText()
layout_item = self.projectLayoutManager.layoutByName(layout_name)
exporter = QgsLayoutExporter(layout_item)
if filename[-3:].lower() == u"pdf":
success = exporter.exportToPdf(
filepath[0], QgsLayoutExporter.PdfExportSettings())
else:
success = exporter.exportToImage(
filepath[0], QgsLayoutExporter.ImageExportSettings())
if success != 0:
QMessageBox.warning(self.iface.mainWindow(),
self.tr("Export Failed"),
self.tr("Failed to export the layout."))
def testIteratorToImages(self):
project, layout = self.prepareIteratorLayout()
atlas = layout.atlas()
atlas.setFilenameExpression(
"'test_exportiteratortoimage_' || \"NAME_1\"")
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
result, error = QgsLayoutExporter.exportToImage(
atlas, self.basetestpath + '/', 'png', settings)
self.assertEqual(result, QgsLayoutExporter.Success, error)
page1_path = os.path.join(
self.basetestpath,
'test_exportiteratortoimage_Basse-Normandie.png')
self.assertTrue(
self.checkImage('iteratortoimage1', 'iteratortoimage1',
page1_path))
page2_path = os.path.join(self.basetestpath,
'test_exportiteratortoimage_Bretagne.png')
self.assertTrue(
self.checkImage('iteratortoimage2', 'iteratortoimage2',
page2_path))
page3_path = os.path.join(self.basetestpath,
'test_exportiteratortoimage_Centre.png')
self.assertTrue(os.path.exists(page3_path))
page4_path = os.path.join(
self.basetestpath,
'test_exportiteratortoimage_Pays de la Loire.png')
self.assertTrue(os.path.exists(page4_path))
def testExcludePagesImage(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
settings.generateWorldFile = False
rendered_file_path = os.path.join(self.basetestpath, 'test_exclude_export.png')
details = QgsLayoutExporter.PageExportDetails()
details.directory = self.basetestpath
details.baseName = 'test_exclude_export'
details.extension = 'png'
details.page = 0
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(exporter.generateFileName(details)))
details.page = 1
self.assertTrue(os.path.exists(exporter.generateFileName(details)))
# exclude a page
l.pageCollection().page(0).setExcludeFromExports(True)
rendered_file_path = os.path.join(self.basetestpath, 'test_exclude_export_excluded.png')
details.baseName = 'test_exclude_export_excluded'
details.page = 0
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(exporter.generateFileName(details)))
details.page = 1
self.assertTrue(os.path.exists(exporter.generateFileName(details)))
# exclude second page
l.pageCollection().page(1).setExcludeFromExports(True)
rendered_file_path = os.path.join(self.basetestpath, 'test_exclude_export_excluded_all.png')
details.baseName = 'test_exclude_export_excluded_all'
details.page = 0
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(exporter.generateFileName(details)))
details.page = 1
self.assertFalse(os.path.exists(exporter.generateFileName(details)))
def testExcludePagesImage(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
settings.generateWorldFile = False
rendered_file_path = os.path.join(self.basetestpath, 'test_exclude_export.png')
details = QgsLayoutExporter.PageExportDetails()
details.directory = self.basetestpath
details.baseName = 'test_exclude_export'
details.extension = 'png'
details.page = 0
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(exporter.generateFileName(details)))
details.page = 1
self.assertTrue(os.path.exists(exporter.generateFileName(details)))
# exclude a page
l.pageCollection().page(0).setExcludeFromExports(True)
rendered_file_path = os.path.join(self.basetestpath, 'test_exclude_export_excluded.png')
details.baseName = 'test_exclude_export_excluded'
details.page = 0
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(exporter.generateFileName(details)))
details.page = 1
self.assertTrue(os.path.exists(exporter.generateFileName(details)))
# exclude second page
l.pageCollection().page(1).setExcludeFromExports(True)
rendered_file_path = os.path.join(self.basetestpath, 'test_exclude_export_excluded_all.png')
details.baseName = 'test_exclude_export_excluded_all'
details.page = 0
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(exporter.generateFileName(details)))
details.page = 1
self.assertFalse(os.path.exists(exporter.generateFileName(details)))
def testExportWorldFile(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add some items
map = QgsLayoutItemMap(l)
map.attemptSetSceneRect(QRectF(30, 60, 200, 100))
extent = QgsRectangle(2000, 2800, 2500, 2900)
map.setExtent(extent)
l.addLayoutItem(map)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
settings.generateWorldFile = False
rendered_file_path = os.path.join(self.basetestpath,
'test_exportwithworldfile.png')
world_file_path = os.path.join(self.basetestpath,
'test_exportwithworldfile.pgw')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings),
QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(rendered_file_path))
self.assertFalse(os.path.exists(world_file_path))
# with world file
settings.generateWorldFile = True
rendered_file_path = os.path.join(self.basetestpath,
'test_exportwithworldfile.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings),
QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(rendered_file_path))
self.assertTrue(os.path.exists(world_file_path))
lines = tuple(open(world_file_path, 'r'))
values = [float(f) for f in lines]
self.assertAlmostEqual(values[0], 0.794117647059, 2)
self.assertAlmostEqual(values[1], 0.0, 2)
self.assertAlmostEqual(values[2], 0.0, 2)
self.assertAlmostEqual(values[3], -0.794251134644, 2)
self.assertAlmostEqual(values[4], 1925.000000000000, 2)
self.assertAlmostEqual(values[5], 3050.000000000000, 2)
def imprimirPlanol(self, x, y, escala, rotacion, projectePlanol,
templateFile, fitxerSortida, tipusSortida):
self.project.read(projectePlanol)
template = QFile(templateFile)
# Creem un document amb la plantilla
doc = QDomDocument()
doc.setContent(template, False)
# Aquest layout no té res a veure amb els layaouts de PyQt.
# Es una plantilla per el projecte. You must believe it.
layout = QgsLayout(self.project)
context = QgsReadWriteContext()
[items, ok] = layout.loadFromTemplate(doc, context)
if ok:
refMap = layout.referenceMap()
rect = refMap.extent()
vector = QgsVector(x - rect.center().x(), y - rect.center().y())
rect += vector
refMap.setExtent(rect)
refMap.setScale(escala)
refMap.setMapRotation(rotacion)
#Depenent del tipus de sortida...
exporter = QgsLayoutExporter(layout)
image_settings = exporter.ImageExportSettings()
image_settings.dpi = 60
# result = exporter.exportToImage('d:/dropbox/qpic/preview.png', image_settings)
# imatge = QPixmap('d:/dropbox/qpic/preview.png')
t = time.localtime()
timestamp = time.strftime('%b-%d-%Y_%H%M%S', t)
if tipusSortida == 'PDF':
settings = QgsLayoutExporter.PdfExportSettings()
settings.dpi = 60
settings.exportMetadata = False
fitxerSortida = 'd:/dropbox/qpic/sortida_' + timestamp + '.PDF'
result = exporter.exportToPdf(fitxerSortida, settings)
print(fitxerSortida)
if tipusSortida == 'PNG':
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 60
# fitxerSortida='sortida_'+timestamp+'.PNG'
fitxerSortida = projectePlanol[0:-4] + '.png'
result = exporter.exportToImage(fitxerSortida, settings)
def testExportReport(self):
p = QgsProject()
r = QgsReport(p)
# add a header
r.setHeaderEnabled(True)
report_header = QgsLayout(p)
report_header.initializeDefaults()
item1 = QgsLayoutItemShape(report_header)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
report_header.addItem(item1)
r.setHeader(report_header)
# add a footer
r.setFooterEnabled(True)
report_footer = QgsLayout(p)
report_footer.initializeDefaults()
item2 = QgsLayoutItemShape(report_footer)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
report_footer.addItem(item2)
r.setFooter(report_footer)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
report_path = os.path.join(self.basetestpath, 'test_report')
result, error = QgsLayoutExporter.exportToImage(
r, report_path, 'png', settings)
self.assertEqual(result, QgsLayoutExporter.Success, error)
page1_path = os.path.join(self.basetestpath, 'test_report_0001.png')
self.assertTrue(
self.checkImage('report_page1', 'report_page1', page1_path))
page2_path = os.path.join(self.basetestpath, 'test_report_0002.png')
self.assertTrue(
self.checkImage('report_page2', 'report_page2', page2_path))
def testExportWorldFile(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add some items
map = QgsLayoutItemMap(l)
map.attemptSetSceneRect(QRectF(30, 60, 200, 100))
extent = QgsRectangle(2000, 2800, 2500, 2900)
map.setExtent(extent)
l.addLayoutItem(map)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
settings.generateWorldFile = False
rendered_file_path = os.path.join(self.basetestpath, 'test_exportwithworldfile.png')
world_file_path = os.path.join(self.basetestpath, 'test_exportwithworldfile.pgw')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(rendered_file_path))
self.assertFalse(os.path.exists(world_file_path))
# with world file
settings.generateWorldFile = True
rendered_file_path = os.path.join(self.basetestpath, 'test_exportwithworldfile.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(rendered_file_path))
self.assertTrue(os.path.exists(world_file_path))
lines = tuple(open(world_file_path, 'r'))
values = [float(f) for f in lines]
self.assertAlmostEqual(values[0], 0.794117647059, 2)
self.assertAlmostEqual(values[1], 0.0, 2)
self.assertAlmostEqual(values[2], 0.0, 2)
self.assertAlmostEqual(values[3], -0.794251134644, 2)
self.assertAlmostEqual(values[4], 1925.000000000000, 2)
self.assertAlmostEqual(values[5], 3050.000000000000, 2)
def testExportReport(self):
p = QgsProject()
r = QgsReport(p)
# add a header
r.setHeaderEnabled(True)
report_header = QgsLayout(p)
report_header.initializeDefaults()
item1 = QgsLayoutItemShape(report_header)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
report_header.addItem(item1)
r.setHeader(report_header)
# add a footer
r.setFooterEnabled(True)
report_footer = QgsLayout(p)
report_footer.initializeDefaults()
item2 = QgsLayoutItemShape(report_footer)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
report_footer.addItem(item2)
r.setFooter(report_footer)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
report_path = os.path.join(self.basetestpath, 'test_report')
result, error = QgsLayoutExporter.exportToImage(r, report_path, 'png', settings)
self.assertEqual(result, QgsLayoutExporter.Success, error)
page1_path = os.path.join(self.basetestpath, 'test_report_0001.png')
self.assertTrue(self.checkImage('report_page1', 'report_page1', page1_path))
page2_path = os.path.join(self.basetestpath, 'test_report_0002.png')
self.assertTrue(self.checkImage('report_page2', 'report_page2', page2_path))
def testIteratorToImages(self):
project, layout = self.prepareIteratorLayout()
atlas = layout.atlas()
atlas.setFilenameExpression("'test_exportiteratortoimage_' || \"NAME_1\"")
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
result, error = QgsLayoutExporter.exportToImage(atlas, self.basetestpath + '/', 'png', settings)
self.assertEqual(result, QgsLayoutExporter.Success, error)
page1_path = os.path.join(self.basetestpath, 'test_exportiteratortoimage_Basse-Normandie.png')
self.assertTrue(self.checkImage('iteratortoimage1', 'iteratortoimage1', page1_path))
page2_path = os.path.join(self.basetestpath, 'test_exportiteratortoimage_Bretagne.png')
self.assertTrue(self.checkImage('iteratortoimage2', 'iteratortoimage2', page2_path))
page3_path = os.path.join(self.basetestpath, 'test_exportiteratortoimage_Centre.png')
self.assertTrue(os.path.exists(page3_path))
page4_path = os.path.join(self.basetestpath, 'test_exportiteratortoimage_Pays de la Loire.png')
self.assertTrue(os.path.exists(page4_path))
def exportMap(self, composition, debugMode):
basename = self.mi + '_' + self.inom if self.mi else self.inom
exporter = QgsLayoutExporter(composition)
exportStatus = 0
if not debugMode:
pdfFilePath = os.path.join(self.exportFolder, f'{basename}.pdf')
pdfExporterSettings = QgsLayoutExporter.PdfExportSettings()
pdfExporterSettings.rasterizeWholeImage = True
pdfExporterSettings.simplifyGeometries = False
pdfExporterSettings.appendGeoreference = True
pdfExporterSettings.exportMetadata = False
pdfExporterSettings.dpi = 400
exportStatus += exporter.exportToPdf(pdfFilePath, pdfExporterSettings)
if self.dlgCfg.exportTiff:
tiffFilePath = os.path.join(self.exportFolder, f'{basename}.tif')
tiffExporterSettings = QgsLayoutExporter.ImageExportSettings()
tiffExporterSettings.dpi = 400
statusTiff = exporter.exportToImage(tiffFilePath, tiffExporterSettings)
exportStatus += statusTiff
del exporter
return not bool(exportStatus)
def print_layout(
project: QgsProject,
layout_name: str,
output_format: OutputFormat,
feature_filter: str = None,
scales: list = None,
scale: int = None,
**kwargs,
):
"""Generate a PDF for an atlas or a report.
:param project: The QGIS project.
:type project: QgsProject
:param layout_name: Name of the layout of the atlas or report.
:type layout_name: basestring
:param feature_filter: QGIS Expression to use to select the feature.
It can return many features, a multiple pages PDF will be returned.
This is required to print atlas, not report
:type feature_filter: basestring
:param scale: A scale to force in the atlas context. Default to None.
:type scale: int
:param scales: A list of predefined list of scales to force in the atlas context.
Default to None.
:type scales: list
:param output_format: The output format, default to PDF if not provided.
:return: Path to the PDF.
:rtype: basestring
"""
canvas = QgsMapCanvas()
bridge = QgsLayerTreeMapCanvasBridge(project.layerTreeRoot(), canvas)
bridge.setCanvasLayers()
manager = project.layoutManager()
master_layout = manager.layoutByName(layout_name)
if output_format == OutputFormat.Svg:
settings = QgsLayoutExporter.SvgExportSettings()
elif output_format in (OutputFormat.Png, OutputFormat.Jpeg):
settings = QgsLayoutExporter.ImageExportSettings()
else:
# PDF by default
settings = QgsLayoutExporter.PdfExportSettings()
atlas = None
atlas_layout = None
report_layout = None
logger = Logger()
if not master_layout:
raise AtlasPrintException("Layout `{}` not found".format(layout_name))
if master_layout.layoutType() == QgsMasterLayoutInterface.PrintLayout:
for _print_layout in manager.printLayouts():
if _print_layout.name() == layout_name:
atlas_layout = _print_layout
break
atlas = atlas_layout.atlas()
if not atlas.enabled():
raise AtlasPrintException("The layout is not enabled for an atlas")
layer = atlas.coverageLayer()
if feature_filter is None:
raise AtlasPrintException(
"EXP_FILTER is mandatory to print an atlas layout")
feature_filter = optimize_expression(layer, feature_filter)
expression = QgsExpression(feature_filter)
if expression.hasParserError():
raise AtlasPrintException(
"Expression is invalid, parser error: {}".format(
expression.parserErrorString()))
context = QgsExpressionContext()
context.appendScope(QgsExpressionContextUtils.globalScope())
context.appendScope(QgsExpressionContextUtils.projectScope(project))
context.appendScope(
QgsExpressionContextUtils.layoutScope(atlas_layout))
context.appendScope(QgsExpressionContextUtils.atlasScope(atlas))
context.appendScope(QgsExpressionContextUtils.layerScope(layer))
expression.prepare(context)
if expression.hasEvalError():
raise AtlasPrintException(
"Expression is invalid, eval error: {}".format(
expression.evalErrorString()))
atlas.setFilterFeatures(True)
atlas.setFilterExpression(feature_filter)
atlas.updateFeatures()
if scale:
atlas_layout.referenceMap().setAtlasScalingMode(
QgsLayoutItemMap.Fixed)
atlas_layout.referenceMap().setScale(scale)
if scales:
atlas_layout.referenceMap().setAtlasScalingMode(
QgsLayoutItemMap.Predefined)
settings.predefinedMapScales = scales
if (not scales and atlas_layout.referenceMap().atlasScalingMode()
== QgsLayoutItemMap.Predefined):
use_project = project.useProjectScales()
map_scales = project.mapScales()
if not use_project or len(map_scales) == 0:
logger.info(
"Map scales not found in project, fetching predefined map scales in global config"
)
map_scales = global_scales()
settings.predefinedMapScales = map_scales
elif master_layout.layoutType() == QgsMasterLayoutInterface.Report:
report_layout = master_layout
else:
raise AtlasPrintException("The layout is not supported by the plugin")
for key, value in kwargs.items():
found = False
if atlas_layout:
item = atlas_layout.itemById(key.lower())
if isinstance(item, QgsLayoutItemLabel):
item.setText(value)
found = True
logger.info(
'Additional parameters "{key}" {found} in layout, value "{value}"'.
format(key=key,
found="found" if found else "not found",
value=value))
file_name = "{}_{}.{}".format(clean_string(layout_name), uuid4(),
output_format.name.lower())
export_path = Path(tempfile.gettempdir()).joinpath(file_name)
Logger().info("Exporting the request in {} using {}".format(
export_path, output_format.value))
if output_format in (OutputFormat.Png, OutputFormat.Jpeg):
exporter = QgsLayoutExporter(atlas_layout or report_layout)
result = exporter.exportToImage(str(export_path), settings)
error = result_message(result)
elif output_format in (OutputFormat.Svg, ):
exporter = QgsLayoutExporter(atlas_layout or report_layout)
result = exporter.exportToSvg(str(export_path), settings)
error = result_message(result)
else:
# Default to PDF
result, error = QgsLayoutExporter.exportToPdf(atlas or report_layout,
str(export_path),
settings)
# Let's override error message
_ = error
error = result_message(result)
if result != QgsLayoutExporter.Success:
raise Exception("Export not generated in QGIS exporter {} : {}".format(
export_path, error))
if not export_path.is_file():
logger.warning(
"No error from QGIS Exporter, but the file does not exist.\n"
"Message from QGIS exporter : {}\n"
"File path : {}\n".format(error, export_path))
raise Exception(
"Export OK from QGIS, but file not found on the file system : {}".
format(export_path))
return export_path
def testExportToImage(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
# add some items
item1 = QgsLayoutItemShape(l)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
l.addItem(item1)
item2 = QgsLayoutItemShape(l)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20), page=1)
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
l.addItem(item2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
rendered_file_path = os.path.join(self.basetestpath,
'test_exporttoimagedpi.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings),
QgsLayoutExporter.Success)
self.assertTrue(
self.checkImage('exporttoimagedpi_page1', 'exporttoimagedpi_page1',
rendered_file_path))
page2_path = os.path.join(self.basetestpath,
'test_exporttoimagedpi_2.png')
self.assertTrue(
self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2',
page2_path))
# crop to contents
settings.cropToContents = True
settings.cropMargins = QgsMargins(10, 20, 30, 40)
rendered_file_path = os.path.join(self.basetestpath,
'test_exporttoimagecropped.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings),
QgsLayoutExporter.Success)
self.assertTrue(
self.checkImage('exporttoimagecropped_page1',
'exporttoimagecropped_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath,
'test_exporttoimagecropped_2.png')
self.assertTrue(
self.checkImage('exporttoimagecropped_page2',
'exporttoimagecropped_page2', page2_path))
# specific pages
settings.cropToContents = False
settings.pages = [1]
rendered_file_path = os.path.join(self.basetestpath,
'test_exporttoimagepages.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings),
QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath,
'test_exporttoimagepages_2.png')
self.assertTrue(
self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2',
page2_path))
# image size
settings.imageSize = QSize(600, 851)
rendered_file_path = os.path.join(self.basetestpath,
'test_exporttoimagesize.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings),
QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath,
'test_exporttoimagesize_2.png')
self.assertTrue(
self.checkImage('exporttoimagesize_page2',
'exporttoimagesize_page2', page2_path))
def saveAsIMG(self):
fullpath, format = QFileDialog.getSaveFileName(self, '存储为img', '', '*.jpg;;*.png')
print(fullpath)
exporter = QgsLayoutExporter(self.layout)
exporter.exportToImage(fullpath, QgsLayoutExporter.ImageExportSettings())
def exportLayout(self, cView, folder, title):
"""Function that sets how to export files."""
currProject = QgsProject.instance()
printer = QPrinter()
painter = QPainter()
exporter = QgsLayoutExporter(cView)
# Set page progressbar maximum value
self.dlg.pageBar.setValue(0)
self.dlg.pageBar.setMaximum(11)
# Do the export process
if not os.path.exists(os.path.join(folder, title)):
os.makedirs(os.path.join(folder, title))
exporter.exportToPdf(os.path.join(folder, title, title + '.pdf'),
QgsLayoutExporter.PdfExportSettings())
exporter.exportToImage(os.path.join(folder, title, title + '.jpg'),
QgsLayoutExporter.ImageExportSettings())
# read CSV file & load into list
with open(os.path.join(self.plugin_dir, "input/metadata_items.csv"),
'r') as metadata_file:
reader = csv.reader(metadata_file, delimiter=',')
metadata_list = list(reader)
settings = ET.Element("mapdoc")
mapdata = ET.SubElement(settings, "mapdata")
# output fixed QGIS variables to XML
"""ACTION?"""
# output project variables listed in CSV to XML
for x in metadata_list:
ma_variable = str(x[0])
elem_name = str(x[1])
elem_name = elem_name.strip()
ma_level = str(x[2])
ma_level = ma_level.strip()
if (ma_level == 'project') and (elem_name != 'no_xml'):
elem_value = str(
QgsExpressionContextUtils.projectScope(
currProject).variable(ma_variable))
ET.SubElement(mapdata, elem_name).text = elem_value
if elem_value.strip():
QgsMessageLog.logMessage(
ma_variable + ' exported as ' + elem_value,
'MapExport', Qgis.Info)
else:
msgBar.pushMessage(
'Warning: missing value for ' + ma_variable, 5)
QgsMessageLog.logMessage(
'Warning: missing value for ' + ma_variable,
'MapExport')
themes = ET.SubElement(mapdata, "themes")
for theme in self.dlg.themeBox.findChildren(QCheckBox):
if theme.isChecked():
ET.SubElement(themes, 'theme').text = theme.text()
for layout in QgsProject.instance().layoutManager().printLayouts():
# Set values of internal variables
if layout.name() == self.dlg.layoutSelect.currentText():
date_now = datetime.date.today().strftime("%B %d, %Y")
ET.SubElement(mapdata, 'lastUpdated').text = date_now
title = layout.name()
ET.SubElement(mapdata,
'jpgfilename').text = layout.name() + '.jpg'
ET.SubElement(mapdata,
'pdffilename').text = layout.name() + '.pdf'
# Action: Which map is selected by this?
item = layout.referenceMap()
# item = layout.itemById('main')
# Get the attr by name and call
map_scale = getattr(item, 'scale')()
ET.SubElement(mapdata, 'scale').text = str(round(map_scale))
map_extent = item.extent()
map_xmin = map_extent.xMinimum()
map_xmax = map_extent.xMaximum()
map_ymin = map_extent.yMinimum()
map_ymax = map_extent.yMaximum()
QgsMessageLog.logMessage('Scale ' + str(map_xmin), 'MapExport',
Qgis.Info)
ET.SubElement(mapdata, 'xmin').text = str(round(map_xmin))
ET.SubElement(mapdata, 'xmax').text = str(round(map_xmax))
ET.SubElement(mapdata, 'ymin').text = str(round(map_ymin))
ET.SubElement(mapdata, 'ymax').text = str(round(map_ymax))
for x in metadata_list:
ma_variable = str(x[0])
elem_name = str(x[1])
elem_name = elem_name.strip()
ma_level = str(x[2])
ma_level = ma_level.strip()
if ma_level == 'layout':
elem_value = str(
QgsExpressionContextUtils.layoutScope(
layout).variable(ma_variable))
ET.SubElement(mapdata, elem_name).text = elem_value
if elem_value.strip():
QgsMessageLog.logMessage(
ma_variable + ' exported as ' + elem_value,
'MapExport', Qgis.Info)
else:
msgBar.pushMessage(
'Warning: missing value for ' + ma_variable, 5)
QgsMessageLog.logMessage(
'Warning: missing value for ' + ma_variable,
'MapExport')
tree = ET.ElementTree(settings)
tree.write(os.path.join(folder, title, title + '.xml'))
# Set the location and the file name of the zip
zippath = os.path.join(folder, title)
zf = zipfile.ZipFile(
os.path.abspath(folder) + os.sep + title + ".zip", "w")
for dirnames, folders, files in os.walk(os.path.join(folder, title)):
# for root, dirs, files in os.walk(folder):
for file in files:
zf.write(os.path.join(os.path.join(folder, title), file), file)
zf.close()
self.pageProcessed()
def exportCompo(self, cView, folder, title, extension):
"""Function that sets how to export files.
Returns a file
:param cView: The print layout to export
:param folder: The folder in which to store the output file
:param title: The print layout name
:param extension: The file extension to use for the output
:return: A file representing the layout in the selected format
"""
#self.msgWMSWarning(cView)
myAtlas = cView.atlas()
#Let's use custom export properties if there are
exportSettings = self.overrideExportSettings(cView, extension)
# Do the export process
exporter = QgsLayoutExporter(cView)
if myAtlas.enabled():
feedback = QgsFeedback()
# if single file export is required (only compatible with pdf, yet)
# singleFile can be true and None in that case
if cView.customProperty(
'singleFile') is not False and extension == '.pdf':
result, error = exporter.exportToPdf(
myAtlas, os.path.join(folder, title + '.pdf'),
exportSettings, feedback)
else: #If instead multiple files will be output
# Check if there's a valid expression for filenames,
# and otherwise inform that a default one will be used and set it using the layout name.
# replacement in the GUI is failing at the moment
# if len(myAtlas.filenameExpression()) == 0:
# self.iface.messageBar().pushMessage(
# self.tr(u'Empty filename expression'),
# self.tr(u'The print layout "{}" has an empty output filename expression. {}_@atlas_pagename is used as default.').format(title, title),
# level = Qgis.Warning
# )
# myAtlas.setFilenameExpression(u"'{}_'||@atlas_pagename".format(title))
current_fileName = myAtlas.filenameExpression()
#export atlas to multiple pdfs
if extension == '.pdf':
result, error = exporter.exportToPdfs(
myAtlas, os.path.join(folder, current_fileName),
exportSettings, feedback)
# export atlas to svg format
elif extension == '.svg':
result, error = exporter.exportToSvg(
myAtlas, os.path.join(folder, current_fileName),
exportSettings, feedback)
# export atlas to image format
else:
result, error = exporter.exportToImage(
myAtlas, os.path.join(folder, current_fileName),
extension, exportSettings, feedback)
myAtlas.endRender()
# if the composition has no atlas
else:
if extension == '.pdf':
result = exporter.exportToPdf(
os.path.join(folder, title + '.pdf'), exportSettings)
elif extension == '.svg':
result = exporter.exportToSvg(
os.path.join(folder, title + '.svg'), exportSettings)
else:
result = exporter.exportToImage(
os.path.join(folder, title + extension), exportSettings)
return result == QgsLayoutExporter.Success
def export_atlas(qgs_project_path, layout_name, filepath):
imageExtension = os.path.splitext(filepath)[1]
imageExtension = imageExtension.lower()
# Open existing project
project = QgsProject.instance()
print(os.path.abspath(os.path.dirname(qgs_project_path)))
os.chdir(os.path.abspath(os.path.dirname(qgs_project_path)))
project.read(os.path.abspath(qgs_project_path))
project.readPath(os.path.abspath(os.path.dirname(qgs_project_path)))
#print(f'Project in "{project.fileName()} loaded successfully')
print('Project in "{fn} loaded successfully'.format(fn=project.fileName()))
# Open prepared layout that as atlas enabled and set
layout = project.layoutManager().layoutByName(layout_name)
# Export atlas
exporter = QgsLayoutExporter(layout)
settings = QgsLayoutExporter.ImageExportSettings()
img_path = os.path.dirname(filepath)
filename = os.path.basename(filepath)
myAtlas = layout.atlas()
myAtlasMap = myAtlas.layout()
myAtlas.setFilenameExpression(img_path)
pdf_settings = QgsLayoutExporter(myAtlasMap).PdfExportSettings()
image_settings = QgsLayoutExporter(myAtlasMap).ImageExportSettings()
image_settings.dpi = 96
svg_settings = QgsLayoutExporter(myAtlasMap).SvgExportSettings(
) #https://qgis.org/api/structQgsLayoutExporter_1_1SvgExportSettings.html
print('layout_name= {layout_name} '.format(layout_name=layout_name))
print('try export to {img_path} '.format(img_path=img_path))
if imageExtension == '.jpg':
if os.path.isfile(os.path.join(img_path, 'output_0.jpg')):
os.unlink(os.path.join(img_path, 'output_0.jpg'))
for layout in QgsProject.instance().layoutManager().printLayouts():
if myAtlas.enabled():
print('signal')
result, error = QgsLayoutExporter.exportToImage(
myAtlas,
baseFilePath=img_path + '//',
extension=imageExtension,
settings=image_settings)
if not result == QgsLayoutExporter.Success:
print(error)
os.rename(os.path.join(img_path, 'output_0.jpg'),
os.path.join(img_path, filename))
if imageExtension == '.png':
if os.path.isfile(os.path.join(img_path, 'output_0.png')):
os.unlink(os.path.join(img_path, 'output_0.png'))
for layout in QgsProject.instance().layoutManager().printLayouts():
if myAtlas.enabled():
print('signal')
result, error = QgsLayoutExporter.exportToImage(
myAtlas,
baseFilePath=img_path + '//',
extension=imageExtension,
settings=image_settings)
if not result == QgsLayoutExporter.Success:
print(error)
os.rename(os.path.join(img_path, 'output_0.png'),
os.path.join(img_path, filename))
if imageExtension == '.pdf':
#if os.path.isfile(os.path.join(img_path,'output_0.jpg')):
# os.unlink(os.path.join(img_path,'output_0.jpg'))
for layout in QgsProject.instance().layoutManager().printLayouts():
if myAtlas.enabled():
result, error = QgsLayoutExporter.exportToPdf(
myAtlas,
img_path + '//output_0.pdf',
settings=pdf_settings)
if not result == QgsLayoutExporter.Success:
print(error)
os.rename(os.path.join(img_path, 'output_0.pdf'),
os.path.join(img_path, filename))
if imageExtension == '.svg':
for layout in QgsProject.instance().layoutManager().printLayouts():
if myAtlas.enabled():
result, error = QgsLayoutExporter.exportToSvg(
myAtlas,
img_path + '//output_0.svg',
settings=svg_settings)
if not result == QgsLayoutExporter.Success:
print(error)
os.rename(os.path.join(img_path, 'output_0.svg'),
os.path.join(img_path, filename))
def testExportToImage(self):
md = QgsProject.instance().metadata()
md.setTitle('proj title')
md.setAuthor('proj author')
md.setCreationDateTime(QDateTime(QDate(2011, 5, 3), QTime(9, 4, 5), QTimeZone(36000)))
md.setIdentifier('proj identifier')
md.setAbstract('proj abstract')
md.setKeywords({'kw': ['kw1', 'kw2'], 'KWx': ['kw3', 'kw4']})
QgsProject.instance().setMetadata(md)
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
# add some items
item1 = QgsLayoutItemShape(l)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
l.addItem(item1)
item2 = QgsLayoutItemShape(l)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20), page=1)
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
l.addItem(item2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagedpi.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(self.checkImage('exporttoimagedpi_page1', 'exporttoimagedpi_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagedpi_2.png')
self.assertTrue(self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2', page2_path))
for f in (rendered_file_path, page2_path):
d = gdal.Open(f)
metadata = d.GetMetadata()
self.assertEqual(metadata['Author'], 'proj author')
self.assertEqual(metadata['Created'], '2011-05-03T09:04:05+10:00')
self.assertEqual(metadata['Keywords'], 'KWx: kw3,kw4;kw: kw1,kw2')
self.assertEqual(metadata['Subject'], 'proj abstract')
self.assertEqual(metadata['Title'], 'proj title')
# crop to contents
settings.cropToContents = True
settings.cropMargins = QgsMargins(10, 20, 30, 40)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagecropped.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(self.checkImage('exporttoimagecropped_page1', 'exporttoimagecropped_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagecropped_2.png')
self.assertTrue(self.checkImage('exporttoimagecropped_page2', 'exporttoimagecropped_page2', page2_path))
# specific pages
settings.cropToContents = False
settings.pages = [1]
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagepages.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagepages_2.png')
self.assertTrue(self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2', page2_path))
# image size
settings.imageSize = QSize(600, 851)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagesize.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagesize_2.png')
self.assertTrue(self.checkImage('exporttoimagesize_page2', 'exporttoimagesize_page2', page2_path))
# image size with incorrect aspect ratio
# this can happen as a result of data defined page sizes
settings.imageSize = QSize(851, 600)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagesizebadaspect.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagesizebadaspect_2.png')
im = QImage(page2_path)
self.assertTrue(self.checkImage('exporttoimagesize_badaspect', 'exporttoimagedpi_page2', page2_path), '{}x{}'.format(im.width(), im.height()))
def testExportToImage(self):
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
# add some items
item1 = QgsLayoutItemShape(l)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
l.addItem(item1)
item2 = QgsLayoutItemShape(l)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20), page=1)
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
l.addItem(item2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagedpi.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(self.checkImage('exporttoimagedpi_page1', 'exporttoimagedpi_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagedpi_2.png')
self.assertTrue(self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2', page2_path))
# crop to contents
settings.cropToContents = True
settings.cropMargins = QgsMargins(10, 20, 30, 40)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagecropped.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(self.checkImage('exporttoimagecropped_page1', 'exporttoimagecropped_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagecropped_2.png')
self.assertTrue(self.checkImage('exporttoimagecropped_page2', 'exporttoimagecropped_page2', page2_path))
# specific pages
settings.cropToContents = False
settings.pages = [1]
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagepages.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagepages_2.png')
self.assertTrue(self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2', page2_path))
# image size
settings.imageSize = QSize(600, 851)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagesize.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagesize_2.png')
self.assertTrue(self.checkImage('exporttoimagesize_page2', 'exporttoimagesize_page2', page2_path))
def print_map(self, tav_num):
self.tav_num = tav_num
p = QgsProject.instance()
crs = QgsCoordinateReferenceSystem()
crs.createFromSrid(self.SRS)
p.setCrs(crs)
l = QgsLayout(p)
l.initializeDefaults()
page = l.pageCollection().page(0)
# map - this item tells the libraries where to put the map itself. Here we create a map and stretch it over the whole paper size:
x, y = 0, 0 # angolo 0, o in alto a sx
if (0 <= self.width <= 297) and (0 <= self.height <= 210):
width, height = 297, 210 # Formato A4 Landscape
elif (0 <= self.height <= 297) and (0 <= self.width <= 210):
width, height = 210, 297 # Formato A4
elif (0 <= self.width <= 420) and (0 <= self.height <= 297):
width, height = 297, 420 # Formato A3 Landscape
elif (0 <= self.height <= 420) and (0 <= self.width <= 297):
width, height = 240, 297 # Formato A4
elif (0 <= self.width <= 1189) and (0 <= self.height <= 841):
width, height = 1189, 841 # Formato A0 Landscape
elif (0 <= self.height <= 1189) and (0 <= self.width <= 841):
width, height = 841, 1189 # Formato A0
else:
width, height = self.width * 1.2, self.height * 1.2 # self.width*10, self.height*10 da un valore alla larghezza e altezza del foglio aumentato di 5 per dare un margine
size = QgsLayoutSize(width, height)
page.setPageSize(size)
map = QgsLayoutItemMap(l)
rect = self.getMapExtentFromMapCanvas(page.pageSize().width(),
page.pageSize().height(), 20.0)
map.attemptSetSceneRect(
QRectF(0, 0,
page.pageSize().width(),
page.pageSize().height()))
map.setExtent(rect)
map.setLayers([self.layerUS])
l.setReferenceMap(map)
l.addLayoutItem(map)
intestazioneLabel = QgsLayoutItemLabel(l)
txt = "Tavola %s - US:%d " % (self.tav_num + 1, self.us)
intestazioneLabel.setText(txt)
intestazioneLabel.adjustSizeToText()
intestazioneLabel.attemptMove(QgsLayoutPoint(1, 0), page=0)
intestazioneLabel.setFrameEnabled(False)
l.addLayoutItem(intestazioneLabel)
scaleLabel = QgsLayoutItemLabel(l)
txt = "Scala: "
scaleLabel.setText(txt)
scaleLabel.adjustSizeToText()
scaleLabel.attemptMove(QgsLayoutPoint(1, 5), page=0)
scaleLabel.setFrameEnabled(False)
l.addLayoutItem(scaleLabel)
# aggiunge la scale bar
scaleBarItem = QgsLayoutItemScaleBar(l)
scaleBarItem.setStyle('Numeric') # optionally modify the style
scaleBarItem.setLinkedMap(map)
scaleBarItem.applyDefaultSize()
scaleBarItem.attemptMove(QgsLayoutPoint(10, 5), page=0)
scaleBarItem.setFrameEnabled(False)
l.addLayoutItem(scaleBarItem)
le = QgsLayoutExporter(l)
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 100
MAPS_path = '{}{}{}'.format(self.HOME, os.sep,
"pyarchinit_MAPS_folder")
tav_name = "Tavola_{}_us_{}.png".format(self.tav_num + 1, self.us)
filename_png = '{}{}{}'.format(MAPS_path, os.sep, tav_name)
le.exportToImage(filename_png, settings)
self.remove_layer()
def testExportToImage(self):
md = QgsProject.instance().metadata()
md.setTitle('proj title')
md.setAuthor('proj author')
md.setCreationDateTime(QDateTime(QDate(2011, 5, 3), QTime(9, 4, 5), QTimeZone(36000)))
md.setIdentifier('proj identifier')
md.setAbstract('proj abstract')
md.setKeywords({'kw': ['kw1', 'kw2']})
QgsProject.instance().setMetadata(md)
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
# add some items
item1 = QgsLayoutItemShape(l)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
l.addItem(item1)
item2 = QgsLayoutItemShape(l)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20), page=1)
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
l.addItem(item2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagedpi.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(self.checkImage('exporttoimagedpi_page1', 'exporttoimagedpi_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagedpi_2.png')
self.assertTrue(self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2', page2_path))
for f in (rendered_file_path, page2_path):
d = gdal.Open(f)
metadata = d.GetMetadata()
self.assertEqual(metadata['Author'], 'proj author')
self.assertEqual(metadata['Created'], '2011-05-03T09:04:05+10:00')
self.assertIn(metadata['Keywords'], ('kw1,kw2', 'kw2,kw1'))
self.assertEqual(metadata['Subject'], 'proj abstract')
self.assertEqual(metadata['Title'], 'proj title')
# crop to contents
settings.cropToContents = True
settings.cropMargins = QgsMargins(10, 20, 30, 40)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagecropped.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(self.checkImage('exporttoimagecropped_page1', 'exporttoimagecropped_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagecropped_2.png')
self.assertTrue(self.checkImage('exporttoimagecropped_page2', 'exporttoimagecropped_page2', page2_path))
# specific pages
settings.cropToContents = False
settings.pages = [1]
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagepages.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagepages_2.png')
self.assertTrue(self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2', page2_path))
# image size
settings.imageSize = QSize(600, 851)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagesize.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagesize_2.png')
self.assertTrue(self.checkImage('exporttoimagesize_page2', 'exporttoimagesize_page2', page2_path))
def imprimirPlanol(self, x, y, escala, rotacion, midaPagina, templateFile,
fitxerSortida, tipusSortida):
tInicial = time.time()
template = QFile(templateFile)
doc = QDomDocument()
doc.setContent(template, False)
layout = QgsLayout(self.project)
# page=QgsLayoutItemPage(layout)
# page.setPageSize(midaPagina)
# layout.pageCollection().addPage(page)
# layout.initializeDefaults()
# p=layout.pageCollection().pages()[0]
# p.setPageSize(midaPagina)
context = QgsReadWriteContext()
[items, ok] = layout.loadFromTemplate(doc, context)
# p=layout.pageCollection().pages()[0]
# p.setPageSize(midaPagina)
if ok:
refMap = layout.referenceMap()
titol = layout.itemById('idNomMapa')
dataMapa = layout.itemById('idData')
if self.leTitol.text() != '':
titol.setText(self.leTitol.text()) #comentat pk peta
else:
titol.setText('')
try:
t = time.localtime()
dataMapa.setText(strftime('%b-%d-%Y %H:%M', t))
except:
pass
rect = refMap.extent()
vector = QgsVector(x - rect.center().x(), y - rect.center().y())
rect += vector
refMap.setExtent(rect)
refMap.setScale(escala)
refMap.setMapRotation(rotacion)
#Depenent del tipus de sortida...
exporter = QgsLayoutExporter(layout)
# image_settings = exporter.ImageExportSettings()
# image_settings.dpi = 30
# result = exporter.exportToImage('d:/dropbox/qpic/preview.png', image_settings)
# imatge = QPixmap('d:/dropbox/qpic/preview.png')
# self.ui.lblImatgeResultat.setPixmap(imatge)
if tipusSortida == 'PDF':
settings = QgsLayoutExporter.PdfExportSettings()
settings.dpi = 300
settings.exportMetadata = False
# fitxerSortida='d:/sortida_'+timestamp+'.PDF'
fitxerSortida += '.PDF'
result = exporter.exportToPdf(
fitxerSortida, settings) #Cal desar el resultat (???)
print(fitxerSortida)
if tipusSortida == 'PNG':
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 300
# fitxerSortida='d:/sortida_'+timestamp+'.PNG'
fitxerSortida += '.PNG'
result = exporter.exportToImage(
fitxerSortida, settings) #Cal desar el resultat (???)
#Obra el document si està marcat checkObrirResultat
QDesktopServices().openUrl(QUrl(fitxerSortida))
segonsEmprats = round(time.time() - tInicial, 1) #???
layersTemporals = self.project.mapLayersByName(
"Capa temporal d'impressió")
estatDirtybit = self.parent.canvisPendents
for layer in layersTemporals:
self.project.removeMapLayer(layer.id())
self.parent.setDirtyBit(estatDirtybit)
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = massprintlabDialog()
# задание списка возможных форматов вывода на печать
format_list = ['png', 'pdf']
# задание списка масштабного ранжирования
scalerange_rule_list = ['линейная шкала', 'логарифмическая шкала']
# задание операторов для фильтра
filter_operators = [
'None', '=', '!=', '<', '<=', '>', '>=', 'LIKE', 'ILIKE', '%',
'IN', 'NOT IN'
]
# словарь единиц измерения
UnitsPerSegment_dict = {'метры': 0, 'километры': 1}
# получение списка макетов в проекте
curLayouts = QgsProject.instance().layoutManager().layouts()
layout_list = []
for layout in curLayouts:
layout_list.append(layout.name())
def select_output_file():
file_path = QtWidgets.QFileDialog.getExistingDirectory(
self.dlg, "Выбери папку для записи ", "")
self.dlg.lineEdit_saver.setText(f'{file_path}')
def defQuery():
layer = self.dlg.mMapLayerComboBox_mf_lay.currentLayer()
iface.setActiveLayer(layer)
iface.zoomToActiveLayer()
field_1 = self.dlg.mFieldComboBox_mf_lay.currentField()
layer_dp = layer.dataProvider()
layer_unique = list(
layer_dp.uniqueValues(layer_dp.fieldNameIndex(field_1)))
return layer_unique, layer, field_1
def namer():
#надо переписать, сейчас в качестве примера имени выводится любое уникальное значение из определённого столбца слоя
#надо, чтобы выводилось значения полей от одной строки (объекта)
self.dlg.lineEdit_namer.clear()
layer = self.dlg.mMapLayerComboBox_namer.currentLayer()
layer_dp = layer.dataProvider()
field_namer_1 = self.dlg.mFieldComboBox_namer_1.currentField()
field_namer_2 = self.dlg.mFieldComboBox_namer_2.currentField()
field_namer_3 = self.dlg.mFieldComboBox_namer_3.currentField()
field_namer_4 = self.dlg.mFieldComboBox_namer_4.currentField()
try:
field_namer_1_value = list(
layer_dp.uniqueValues(
layer_dp.fieldNameIndex(field_namer_1)))[0]
except:
field_namer_1_value = ''
try:
field_namer_2_value = list(
layer_dp.uniqueValues(
layer_dp.fieldNameIndex(field_namer_2)))[0]
except:
field_namer_2_value = ''
try:
field_namer_3_value = list(
layer_dp.uniqueValues(
layer_dp.fieldNameIndex(field_namer_3)))[0]
except:
field_namer_3_value = ''
try:
field_namer_4_value = list(
layer_dp.uniqueValues(
layer_dp.fieldNameIndex(field_namer_4)))[0]
except:
field_namer_4_value = ''
list_values = np.array([
field_namer_1_value, field_namer_2_value, field_namer_3_value,
field_namer_4_value
])
list_values = list_values[list_values != '']
self.dlg.lineEdit_namer.setText('_'.join(list_values))
return '_'.join(list_values)
def scale_range_selector():
scale_step = self.dlg.mQgsSpinBox_scale.value()
max_scale = int(self.dlg.mScaleRangeWidget.maximumScale())
min_scale = int(self.dlg.mScaleRangeWidget.minimumScale())
scale_range = [
i for i in range(max_scale, min_scale + scale_step, scale_step)
]
if self.dlg.comboBox_range_rule.currentIndex() == 0:
self.dlg.lineEdit_scalerange.setText(str(scale_range))
else:
base = max_scale
end_scale = min_scale
stop = math.log(end_scale, base)
num = self.dlg.mQgsSpinBox_scale_2.value()
scale_range = np.logspace(1,
stop=stop,
num=num,
endpoint=True,
base=base,
dtype=int,
axis=0)
scale_range = np.around(scale_range, -2)
self.dlg.lineEdit_scalerange.setText(str(scale_range))
return scale_range
# filter function
def filt_by_iddb(layer, filter_field, value):
layer.setSubsetString(f'"{filter_field}" = {value}')
iface.setActiveLayer(layer)
iface.zoomToActiveLayer()
return layer.extent()
def scale_setter(max_scale, min_scale, cur_scale_value, scale_range):
if (np.array(scale_range) >= cur_scale_value
).all(): # если все значения масштаба больше текущего масштаба
return max_scale
elif (np.array(scale_range) <= cur_scale_value).all(
): # если все значения масштаба меньше текущего масштаба
return min_scale
return np.array(scale_range)[
np.array(scale_range) >= cur_scale_value][0]
def aux_filter(layer, field, operator, link_lay, link_lay_field):
link_lay_dp = link_lay.dataProvider()
if link_lay_dp.featureCount() > 1:
linked_layer_field_values = str(
link_lay_dp.uniqueValues(
link_lay_dp.fieldNameIndex(link_lay_field))).replace(
'{', '(').replace('}', ')')
else:
linked_layer_field_index = link_lay_dp.fieldNameIndex(
link_lay_field)
linked_layer_field_values = \
[feature.attributes()[linked_layer_field_index] for feature in link_lay_dp.getFeatures()][0]
if linked_layer_field_values == '':
linked_layer_field_values = "('zero_value')"
print(f"linked_layer_field_values {linked_layer_field_values}")
print(f'"{field}" {operator} {linked_layer_field_values}')
layer.setSubsetString(
f'"{field}" {operator} {linked_layer_field_values}')
self.dlg.lineEdit_saver.clear()
self.dlg.toolButton_saver.clicked.connect(select_output_file)
self.dlg.comboBox_layout.clear()
self.dlg.comboBox_layout.addItems(layout_list)
self.dlg.comboBox_saver.clear()
self.dlg.comboBox_saver.addItems(format_list)
self.dlg.comboBox_range_rule.clear()
self.dlg.comboBox_range_rule.addItems(scalerange_rule_list)
# show the dialog
self.dlg.show()
#main_filter
self.dlg.mMapLayerComboBox_mf_lay.layerChanged.connect(
self.dlg.mFieldComboBox_mf_lay.setLayer)
# auxiliary_filter
self.dlg.mMapLayerComboBox_layer_1.layerChanged.connect(
self.dlg.mFieldComboBox_layer_1.setLayer)
self.dlg.comboBox_operator_1.addItems(filter_operators)
self.dlg.mMapLayerComboBox_l_lay_1.layerChanged.connect(
self.dlg.mFieldComboBox_l_lay_1.setLayer)
self.dlg.mMapLayerComboBox_layer_2.layerChanged.connect(
self.dlg.mFieldComboBox_layer_2.setLayer)
self.dlg.comboBox_operator_2.addItems(filter_operators)
self.dlg.mMapLayerComboBox_l_lay_2.layerChanged.connect(
self.dlg.mFieldComboBox_l_lay_2.setLayer)
self.dlg.mMapLayerComboBox_layer_3.layerChanged.connect(
self.dlg.mFieldComboBox_layer_3.setLayer)
self.dlg.comboBox_operator_3.addItems(filter_operators)
self.dlg.mMapLayerComboBox_l_lay_3.layerChanged.connect(
self.dlg.mFieldComboBox_l_lay_3.setLayer)
# namer
self.dlg.pushButton_namer.clicked.connect(namer)
self.dlg.mMapLayerComboBox_namer.layerChanged.connect(
self.dlg.mFieldComboBox_namer_1.setLayer)
self.dlg.mMapLayerComboBox_namer.layerChanged.connect(
self.dlg.mFieldComboBox_namer_2.setLayer)
self.dlg.mMapLayerComboBox_namer.layerChanged.connect(
self.dlg.mFieldComboBox_namer_3.setLayer)
self.dlg.mMapLayerComboBox_namer.layerChanged.connect(
self.dlg.mFieldComboBox_namer_4.setLayer)
self.dlg.pushButton_scale.clicked.connect(scale_range_selector)
self.dlg.comboBox_ruler_units.clear()
self.dlg.comboBox_ruler_units.addItems(UnitsPerSegment_dict.keys())
# Run the dialog event loop
result = self.dlg.exec_()
max_scale = int(self.dlg.mScaleRangeWidget.maximumScale())
min_scale = int(self.dlg.mScaleRangeWidget.minimumScale())
scale_range = scale_range_selector()
ruler_min = self.dlg.mQgsSpinBox_ruler_min.value() / (2 * 10**6)
ruler_max = self.dlg.mQgsSpinBox_ruler_max.value() / (2 * 10**6)
units_per_segment = np.array([0.1, 0.25, 0.5, 1, 2, 2.5, 5, 10, 20])
# See if OK was pressed
if result:
selected_layout = curLayouts[
self.dlg.comboBox_layout.currentIndex()]
referencemap = selected_layout.referenceMap()
referencebar = selected_layout.itemById("scalebar")
layer_unique, layer, filter_field = defQuery()
base_path = self.dlg.lineEdit_saver.text()
file_ext = format_list[self.dlg.comboBox_saver.currentIndex()]
try:
os.mkdir(
os.path.join(base_path,
str(date.today()).replace('-', '_')))
write_path = os.path.join(base_path,
str(date.today()).replace('-', '_'))
except FileExistsError:
write_path = os.path.join(base_path,
str(date.today()).replace('-', '_'))
print(write_path)
os.mkdir(
os.path.join(
write_path,
datetime.now().strftime('%H:%M').replace(':', '_')))
write_path = os.path.join(
write_path,
datetime.now().strftime('%H:%M').replace(':', '_'))
file = open(write_path + '/log.txt', 'w')
file.write(
f'ЭТО ЛОГ ФАЙЛ, в папке должно быть {len(layer_unique)} файлов'
)
file.close()
if self.dlg.comboBox_ruler_units.currentIndex() == 0:
units_per_segment = units_per_segment * 1000
ruler_max = ruler_max * 1000
ruler_min = ruler_min * 1000
for value in layer_unique:
extent = filt_by_iddb(layer, filter_field, value)
if filter_operators[
self.dlg.comboBox_operator_1.currentIndex()] != 'None':
aux_filter(
self.dlg.mMapLayerComboBox_layer_1.currentLayer(),
self.dlg.mFieldComboBox_layer_1.currentField(),
filter_operators[
self.dlg.comboBox_operator_1.currentIndex()],
self.dlg.mMapLayerComboBox_l_lay_1.currentLayer(),
self.dlg.mFieldComboBox_l_lay_1.currentField())
if filter_operators[
self.dlg.comboBox_operator_2.currentIndex()] != 'None':
aux_filter(
self.dlg.mMapLayerComboBox_layer_2.currentLayer(),
self.dlg.mFieldComboBox_layer_2.currentField(),
filter_operators[
self.dlg.comboBox_operator_2.currentIndex()],
self.dlg.mMapLayerComboBox_l_lay_2.currentLayer(),
self.dlg.mFieldComboBox_l_lay_2.currentField())
if filter_operators[
self.dlg.comboBox_operator_3.currentIndex()] != 'None':
aux_filter(
self.dlg.mMapLayerComboBox_layer_3.currentLayer(),
self.dlg.mFieldComboBox_layer_3.currentField(),
filter_operators[
self.dlg.comboBox_operator_3.currentIndex()],
self.dlg.mMapLayerComboBox_l_lay_3.currentLayer(),
self.dlg.mFieldComboBox_l_lay_3.currentField())
full_file_path = f"{write_path}/{namer()}.{file_ext}"
iface.openLayoutDesigner(selected_layout)
selected_layout.refresh()
referencemap.zoomToExtent(extent)
cur_scale_value = referencemap.scale()
cur_scale_value = scale_setter(max_scale, min_scale,
cur_scale_value, scale_range)
referencemap.setScale(cur_scale_value)
units_per_segment_value = units_per_segment[
np.where((units_per_segment / cur_scale_value >= ruler_min) & \
(units_per_segment / cur_scale_value <= ruler_max))].max()
referencebar.setUnitsPerSegment(units_per_segment_value)
exporter = QgsLayoutExporter(selected_layout)
if format_list[
self.dlg.comboBox_saver.currentIndex()] == 'png':
exporter.exportToImage(
full_file_path,
QgsLayoutExporter.ImageExportSettings())
elif format_list[
self.dlg.comboBox_saver.currentIndex()] == 'pdf':
exporter.exportToPdf(full_file_path,
QgsLayoutExporter.PdfExportSettings())
else:
print('Неизвестный формат')
break
def TOMsExportAtlas(self, printProposalObject):
# TH (180608): Export function to deal with atlases
settings = QSettings()
format = self.dialogui.comboBox_fileformat.itemData(self.dialogui.comboBox_fileformat.currentIndex())
# TH (180608): Check to see whether or not the Composer is an Atlas
currPrintLayout = self.layoutView
currLayoutAtlas = currPrintLayout.atlas()
success = False
# https://gis.stackexchange.com/questions/77848/programmatically-load-composer-from-template-and-generate-atlas-using-pyqgis?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
self.TOMsSetAtlasValues(currPrintLayout)
currRevisionDate = self.proposalsManager.date()
# get the map tiles that are affected by the Proposal
# self.getProposalTileList(currProposalID, currRevisionDate)
proposalTileDictionaryForDate = printProposalObject.getProposalTileDictionaryForDate(currRevisionDate)
"""self.tileSet = set(
proposalTileDictionaryForDate)""" # TODO: Change around use of tileSet - also might be good to have a current proposal as an object in proposalManager...
# Now check which tiles to use
self.tilesToPrint = self.TOMsChooseTiles(proposalTileDictionaryForDate)
if len(self.tilesToPrint) == 0:
return
# get the output location
dirName = QFileDialog.getExistingDirectory(
self.iface.mainWindow(),
self.tr("Export Composition"),
settings.value("/instantprint/lastdir", ""),
QFileDialog.ShowDirsOnly
)
if not dirName:
return
settings.setValue("/instantprint/lastdir", dirName)
tileIDList = ""
firstTile = True
for tile in self.tilesToPrint:
if firstTile:
tileIDList = str(tile.attribute("id"))
firstTile = False
else:
tileIDList = tileIDList + ',' + str(tile.attribute("id"))
currLayoutAtlas.setFilterFeatures(True)
currLayoutAtlas.setFilterExpression(' "id" in ({tileList})'.format(tileList=tileIDList))
composerRevisionNr = currPrintLayout.itemById('revisionNr')
composerEffectiveDate = currPrintLayout.itemById('effectiveDate')
composerProposalStatus = currPrintLayout.itemById('proposalStatus')
if composerProposalStatus is not None:
composerProposalStatus.setText(self.proposalForPrintingStatusText)
else:
QMessageBox.warning(self.iface.mainWindow(), self.tr("Missing label in Layout"),
self.tr("Missing label 'proposalStatus'"))
composerPrintTypeDetails = currPrintLayout.itemById('printTypeDetails')
if composerPrintTypeDetails is not None:
composerPrintTypeDetails.setText(self.proposalPrintTypeDetails)
else:
QMessageBox.warning(self.iface.mainWindow(), self.tr("Missing label in Layout"),
self.tr("Missing label 'printTypeDetails'"))
# currProposalTitle, currProposalOpenDate = self.getProposalTitle(currProposalID)
#printProposal = printProposalObject
currProposalTitle = printProposalObject.getProposalTitle()
currProposalOpenDate = printProposalObject.getProposalOpenDate()
if printProposalObject.thisProposalNr == 0:
currProposalTitle = "CurrentRestrictions_({date})".format(
date=self.proposalsManager.date().toString('yyyyMMMdd'))
TOMsMessageLog.logMessage("In TOMsExportAtlas. Now printing " + str(currLayoutAtlas.count()) + " items ....",
level=Qgis.Info)
currLayoutAtlas.setEnabled(True)
currLayoutAtlas.updateFeatures()
currLayoutAtlas.beginRender()
altasFeatureFound = currLayoutAtlas.first()
while altasFeatureFound:
currTileNr = int(currLayoutAtlas.nameForPage(currLayoutAtlas.currentFeatureNumber()))
currLayoutAtlas.refreshCurrentFeature()
#tileWithDetails = self.tileFromTileSet(currTileNr)
tileWithDetails = proposalTileDictionaryForDate[currTileNr]
if tileWithDetails == None:
TOMsMessageLog.logMessage("In TOMsExportAtlas. Tile with details not found ....", level=Qgis.Info)
QMessageBox.warning(self.iface.mainWindow(), self.tr("Print Failed"),
self.tr("Could not find details for " + str(currTileNr)))
break
TOMsMessageLog.logMessage("In TOMsExportAtlas. tile nr: " + str(currTileNr) + " RevisionNr: " + str(
tileWithDetails["RevisionNr"]) + " RevisionDate: " + str(tileWithDetails["LastRevisionDate"]),
level=Qgis.Info)
if self.proposalForPrintingStatusText == "CONFIRMED":
composerRevisionNr.setText(str(tileWithDetails["RevisionNr"]))
composerEffectiveDate.setText(
'{date}'.format(date=tileWithDetails["LastRevisionDate"].toString('dd-MMM-yyyy')))
else:
composerRevisionNr.setText(str(tileWithDetails["RevisionNr"] + 1))
# For the Proposal, use the current view date
composerEffectiveDate.setText(
'{date}'.format(date=self.openDateForPrintProposal.toString('dd-MMM-yyyy')))
filename = currProposalTitle + "_" + str(
currTileNr) + "." + self.dialogui.comboBox_fileformat.currentText().lower()
outputFile = os.path.join(dirName, filename)
exporter = QgsLayoutExporter(currLayoutAtlas.layout())
if self.dialogui.comboBox_fileformat.currentText().lower() == u"pdf":
result = exporter.exportToPdf(outputFile, QgsLayoutExporter.PdfExportSettings())
# success = currLayoutAtlas.composition().exportAsPDF(outputFile)
else:
result = exporter.exportToImage(outputFile, 'png', QgsLayoutExporter.ImageExportSettings())
"""image = currLayoutAtlas.composition().printPageAsRaster(0)
if not image.isNull():
success = image.save(outputFile)"""
if result != QgsLayoutExporter.Success:
QMessageBox.warning(self.iface.mainWindow(), self.tr("Print Failed"),
self.tr("Failed to print " + exporter.errorFile()))
break
altasFeatureFound = currLayoutAtlas.next()
currLayoutAtlas.endRender()
QMessageBox.information(self.iface.mainWindow(), "Information",
("Printing completed"))
