def test_windowsDrawingArtifacts(self):
"""Test that windows rendering does not make artifacts"""
# sometimes spurious lines are drawn on the layout
LOGGER.info('Testing windowsDrawingArtifacts')
myPath = unique_filename(
prefix='artifacts',
suffix='.pdf',
dir=temp_dir('test'))
myMap = Map(IFACE)
setup_printer(myPath)
myMap.setup_composition()
myImage = QtGui.QImage(10, 10, QtGui.QImage.Format_RGB32)
myImage.setDotsPerMeterX(dpi_to_meters(300))
myImage.setDotsPerMeterY(dpi_to_meters(300))
#myImage.fill(QtGui.QColor(250, 250, 250))
# Look at the output, you will see antialiasing issues around some
# of the boxes drawn...
# myImage.fill(QtGui.QColor(200, 200, 200))
myImage.fill(200 + 200 * 256 + 200 * 256 * 256)
myFilename = os.path.join(temp_dir(), 'greyBox')
myImage.save(myFilename, 'PNG')
for i in range(10, 190, 10):
myPicture = QgsComposerPicture(myMap.composition)
myPicture.setPictureFile(myFilename)
if qgis_version() >= 10800: # 1.8 or newer
myPicture.setFrameEnabled(False)
else:
myPicture.setFrame(False)
myPicture.setItemPosition(i, # x
i, # y
10, # width
10) # height
myMap.composition.addItem(myPicture)
# Same drawing drawn directly as a pixmap
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
myPixmapItem = myMap.composition.addPixmap(
QtGui.QPixmap.fromImage(myImage))
myPixmapItem.setOffset(i, i + 20)
# Same drawing using our drawImage Helper
myWidthMM = 1
myMap.draw_image(myImage, myWidthMM, i, i + 40)
myImagePath, _, _ = myMap.render()
# when this test no longer matches our broken render hash
# we know the issue is fixed
myTolerance = 0
myFlag, myMessage = check_images(
'windowsArtifacts',
myImagePath,
myTolerance)
myMessage += ('\nWe want these images to match, if they do not '
'there may be rendering artifacts in windows.\n')
assert myFlag, myMessage
def render_template(self, template_path, output_path):
"""Load a QgsComposer map from a template and render it.
.. note:: THIS METHOD IS EXPERIMENTAL AND CURRENTLY NON FUNCTIONAL
:param template_path: Path to the template that should be loaded.
:type template_path: str
:param output_path: Path for the output pdf.
:type output_path: str
"""
self.setup_composition()
myResolution = self.composition.printResolution()
self.printer = setup_printer(
output_path, resolution=myResolution)
if self.composition:
myFile = QtCore.QFile(template_path)
myDocument = QtXml.QDomDocument()
myDocument.setContent(myFile, False) # .. todo:: fix magic param
myNodeList = myDocument.elementsByTagName('Composer')
if myNodeList.size() > 0:
myElement = myNodeList.at(0).toElement()
self.composition.readXML(myElement, myDocument)
self.make_pdf(output_path)
def make_pdf(self, filename):
"""Generate the printout for our final map.
:param filename: Path on the file system to which the pdf should be
saved. If None, a generated file name will be used.
:type filename: str
:returns: File name of the output file (equivalent to filename if
provided).
:rtype: str
"""
LOGGER.debug('InaSAFE Map printToPdf called')
if filename is None:
myMapPdfPath = unique_filename(
prefix='report', suffix='.pdf', dir=temp_dir('work'))
else:
# We need to cast to python string in case we receive a QString
myMapPdfPath = str(filename)
self.compose_map()
self.printer = setup_printer(myMapPdfPath)
_, myImage, myRectangle = self.render()
myPainter = QtGui.QPainter(self.printer)
myPainter.drawImage(myRectangle, myImage, myRectangle)
myPainter.end()
return myMapPdfPath
def to_pdf(self, html, filename=None):
"""Render an html snippet into the printer, paginating as needed.
:param html: A string containing an html snippet. It will have a
header and footer appended to it in order to make it a valid
html document. The header will also apply the bootstrap theme
to the document.
:type html: str
:param filename: String containing a pdf file path that the
output will be written to. If no file name is given we will make
up one for you - nice eh?
:type filename: str
:returns: The file path of the output pdf (which is the same as the
filename parameter if it was specified).
:rtype: str
"""
LOGGER.info('InaSAFE Map printToPdf called')
if filename is None:
html_pdf_path = unique_filename(
prefix='table', suffix='.pdf', dir=temp_dir())
else:
# We need to cast to python string in case we receive a QString
html_pdf_path = str(filename)
self.printer = setup_printer(html_pdf_path)
self.load_and_wait(html_snippet=html)
self.web_view.print_(self.printer)
return html_pdf_path
def printToPdf(self, theHtml, theFilename=None):
"""Render an html snippet into the printer, paginating as needed.
Args:
* theHtml: str A string containing an html snippet. It will have a
header and footer appended to it in order to make it a valid
html document. The header will also apply the bootstrap theme
to the document.
* theFilename: str String containing a pdf file path that the
output will be written to.
Returns:
str: The file path of the output pdf (which is the same as the
theFilename parameter if it was specified.
Raises:
None
"""
LOGGER.info('InaSAFE Map printToPdf called')
if theFilename is None:
myHtmlPdfPath = unique_filename(
prefix='table', suffix='.pdf', dir=temp_dir('work'))
else:
# We need to cast to python string in case we receive a QString
myHtmlPdfPath = str(theFilename)
self.printer = setup_printer(myHtmlPdfPath)
self.loadAndWait(theHtmlSnippet=theHtml)
self.webView.print_(self.printer)
return myHtmlPdfPath
def to_pdf(self, html, filename=None):
"""Render an html snippet into the printer, paginating as needed.
:param html: A string containing an html snippet. It will have a
header and footer appended to it in order to make it a valid
html document. The header will also apply the bootstrap theme
to the document.
:type html: str
:param filename: String containing a pdf file path that the
output will be written to. If no file name is given we will make
up one for you - nice eh?
:type filename: str
:returns: The file path of the output pdf (which is the same as the
filename parameter if it was specified).
:rtype: str
"""
LOGGER.info('InaSAFE Map printToPdf called')
if filename is None:
myHtmlPdfPath = unique_filename(prefix='table',
suffix='.pdf',
dir=temp_dir('work'))
else:
# We need to cast to python string in case we receive a QString
myHtmlPdfPath = str(filename)
self.printer = setup_printer(myHtmlPdfPath)
self.load_and_wait(html_snippet=html)
self.webView.print_(self.printer)
return myHtmlPdfPath
def renderTemplate(self, theTemplateFilePath, theOutputFilePath):
"""Load a QgsComposer map from a template and render it
.. note:: THIS METHOD IS EXPERIMENTAL AND CURRENTLY NON FUNCTIONAL
Args:
theTemplateFilePath - path to the template that should be loaded.
theOutputFilePath - path for the output pdf
Returns:
None
Raises:
None
"""
self.setupComposition()
myResolution = self.composition.printResolution()
self.printer = setup_printer(theOutputFilePath,
resolution=myResolution)
if self.composition:
myFile = QtCore.QFile(theTemplateFilePath)
myDocument = QtXml.QDomDocument()
myDocument.setContent(myFile, False) # .. todo:: fix magic param
myNodeList = myDocument.elementsByTagName('Composer')
if myNodeList.size() > 0:
myElement = myNodeList.at(0).toElement()
self.composition.readXML(myElement, myDocument)
self.printToPdf(theOutputFilePath)
def make_pdf(self, filename):
"""Generate the printout for our final map.
:param filename: Path on the file system to which the pdf should be
saved. If None, a generated file name will be used.
:type filename: str
:returns: File name of the output file (equivalent to filename if
provided).
:rtype: str
"""
LOGGER.debug('InaSAFE Map printToPdf called')
if filename is None:
map_pdf_path = unique_filename(prefix='report',
suffix='.pdf',
dir=temp_dir())
else:
# We need to cast to python string in case we receive a QString
map_pdf_path = str(filename)
self.load_template()
resolution = self.composition.printResolution()
self.printer = setup_printer(map_pdf_path, resolution=resolution)
_, image, rectangle = self.render()
painter = QtGui.QPainter(self.printer)
painter.drawImage(rectangle, image, rectangle)
painter.end()
return map_pdf_path
def render_template(self, template_path, output_path):
"""Load a QgsComposer map from a template and render it.
.. note:: THIS METHOD IS EXPERIMENTAL AND CURRENTLY NON FUNCTIONAL
:param template_path: Path to the template that should be loaded.
:type template_path: str
:param output_path: Path for the output pdf.
:type output_path: str
"""
self.setup_composition()
myResolution = self.composition.printResolution()
self.printer = setup_printer(output_path, resolution=myResolution)
if self.composition:
myFile = QtCore.QFile(template_path)
myDocument = QtXml.QDomDocument()
myDocument.setContent(myFile, False) # .. todo:: fix magic param
myNodeList = myDocument.elementsByTagName('Composer')
if myNodeList.size() > 0:
myElement = myNodeList.at(0).toElement()
self.composition.readXML(myElement, myDocument)
self.make_pdf(output_path)
