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 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 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 overrideExportSettings(self, layout, extension):
"""Because GUI settings are not exposed in Python, we need to find and catch user selection
See discussion at http://osgeo-org.1560.x6.nabble.com/Programmatically-export-layout-with-georeferenced-file-td5365462.html"""
if extension == '.pdf':
exportSettings = QgsLayoutExporter.PdfExportSettings()
if layout.customProperty(
'dpi') and layout.customProperty('dpi') != -1:
exportSettings.dpi = layout.customProperty('dpi')
if layout.customProperty('forceVector') == True:
exportSettings.forceVectorOutput = True
if layout.customProperty('rasterize') == True:
exportSettings.rasterizeWholeImage = True
elif extension == '.svg':
exportSettings = QgsLayoutExporter.SvgExportSettings()
if layout.customProperty(
'dpi') and layout.customProperty('dpi') != -1:
exportSettings.dpi = layout.customProperty('dpi')
if layout.customProperty('forceVector') == True:
exportSettings.forceVectorOutput = True
if layout.customProperty('svgIncludeMetadata') == True:
exportSettings.exportMetadata = True
if layout.customProperty('svgGroupLayers') == True:
exportSettings.exportAsLayers = True
else:
exportSettings = QgsLayoutExporter.ImageExportSettings()
if layout.customProperty('exportWorldFile') == True:
exportSettings.generateWorldFile = True
if layout.customProperty('') == True:
exportSettings.exportMetadata = True
if layout.customProperty(
'dpi') and layout.customProperty('dpi') != -1:
exportSettings.dpi = layout.customProperty('dpi')
# if layout.customProperty('atlasRasterFormat') == True : exportSettings.xxxx = True
# if layout.customProperty('imageAntialias') == True : exportSettings.xxxx = True
return exportSettings
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"))
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 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 saveAsIMG(self):
fullpath, format = QFileDialog.getSaveFileName(self, '存储为img', '', '*.jpg;;*.png')
print(fullpath)
exporter = QgsLayoutExporter(self.layout)
exporter.exportToImage(fullpath, QgsLayoutExporter.ImageExportSettings())
def overrideExportSettings(self, layout, extension):
"""Because GUI settings are not exposed in Python,
we need to find and catch user selection and override
export settings values with what is actually active in the GUI.
See discussion at http://osgeo-org.1560.x6.nabble.com/Programmatically-export-layout-with-georeferenced-file-td5365462.html
"""
if extension == '.pdf':
# See QgsLayoutDesignerDialog::getPdfExportSettings
# let's follow non-default values if set
exportSettings = QgsLayoutExporter.PdfExportSettings()
exportSettings.flags = layout.renderContext().flags()
exportSettings.dpi = layoutDpi
if layout.customProperty('rasterize') in ['true', True]:
exportSettings.rasterizeWholeImage = True
if layout.customProperty('forceVector') == 1:
exportSettings.forceVectorOutput = True
if layout.customProperty('pdfTextFormat') == 1:
exportSettings.textRenderFormat = 1
if layout.customProperty('pdfOgcBestPracticeFormat') == 1:
exportSettings.useIso32000ExtensionFormatGeoreferencing = False
exportSettings.useOgcBestPracticeFormatGeoreferencing = True
if layout.customProperty('pdfExportThemes'):
exportSettings.exportThemes = layout.customProperty(
'pdfExportThemes')
if layout.customProperty('pdfIncludeMetadata') == 0:
exportSettings.exportMetadata = False
if layout.customProperty('pdfSimplify') == 0:
exportSettings.simplifyGeometries = False
if layout.customProperty('pdfCreateGeoPdf') == 1:
exportSettings.writeGeoPdf = True
if layout.customProperty('pdfAppendGeoreference') == 0:
exportSettings.appendGeoreference = False
if layout.customProperty('pdfExportGeoPdfFeatures') == 0:
exportSettings.includeGeoPdfFeatures = False
elif extension == '.svg':
# See QgsLayoutDesignerDialog::getSvgExportSettings
exportSettings = QgsLayoutExporter.SvgExportSettings()
exportSettings.flags = layout.renderContext().flags()
exportSettings.dpi = layoutDpi
if layout.customProperty('forceVector') == 1:
exportSettings.forceVectorOutput = True
if layout.customProperty('svgIncludeMetadata') == 0:
exportSettings.exportMetadata = False
if layout.customProperty('svgSimplify') == 0:
exportSettings.simplifyGeometries = False
if layout.customProperty('svgGroupLayers') in ['true', True]:
exportSettings.exportAsLayers = True
if layout.customProperty('svgTextFormat') == 1:
exportSettings.textRenderFormat = 1
if layout.customProperty('svgCropToContents') in ['true', True]:
exportSettings.cropToContents = True
# Todo: add margin values when cropping to content
#exportSettings.cropMargins = ???QgsMargins???
#if layout.customProperty('svgDisableRasterTiles') in ['true', True] : ??? # to fine tune with flags FlagDisableTiledRasterLayerRenders
else:
# see QgsLayoutDesignerDialog::getRasterExportSettings for settings
exportSettings = QgsLayoutExporter.ImageExportSettings()
exportSettings.flags = layout.renderContext().flags()
exportSettings.dpi = layoutDpi
if layout.customProperty('exportWorldFile') in ['true', True]:
exportSettings.generateWorldFile = True
if layout.customProperty('imageCropToContents') in ['true', True]:
exportSettings.cropToContents = True
# Todo: add margin values when cropping to content
#exportSettings.cropMargins = ???QgsMargins???
# exportSettings.exportMetadata = False # what's the corresponding layout's property?
# layout.customProperty('atlasRasterFormat') # overridden by extension
# # if layout.customProperty('imageAntialias') in ['true', True] : ??? # to fine tune with flags FlagAntialiasing
return exportSettings
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 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 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 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()
