[GIS] Can QGIS map canvas update while python script is running

pyqgis

I want to automate a periodic refresh of the QGIS map canvas with updated shapefiles. A Python plugin or console script does not allow the map to update until the script terminates. Is there a way to force a map refresh in a running plugin or script, or is a stand-alone app required?

Using v1.7.4 now but could migrate to newer version.

Best Answer

You can use the python threading library to run a function periodically:

I have used the following statements to remove a set of graphics after 3 seconds:

from threading import Timer
Timer( 3, self._clearGraphicLayer, ()).start()

def _clearGraphicLayer(self):
  for graphic in  self.graphicsLayer: 
    self.iface.mapCanvas().scene().removeItem(graphic)

  self.iface.mapCanvas().refresh()
  self.graphicsLayer = []

And if needed you can have the callback function restart the timer if a certain condition is not met. But look out if you use this module wrong you can crash the entire application.

More info: https://docs.python.org/2/library/threading.html

Related Solutions

PyQGIS – Making Serial Maps from Template

The object QgsMapRenderer is deprecated in 2.4 and above, so the script wasn’t working properly.

To make the script work it’s necessary to replace it by the object QgsMapSettings. Consequently, also some function names need to be slightly changed (e.g. from setProjectionsEnabled() to setCrsTransformEnabled(), from setLayerSet() to setLayers())

This is the new corrected script, now working also with QGIS 2.4

import os
from qgis.core import *
from qgis.gui import *
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyQt4.QtXml import *
import lxml.etree as etree

print "setting prefix"
QgsApplication.setPrefixPath("/usr", True)
print "initiating qgis"
QgsApplication.initQgis()
print 'creating new app'
app = QgsApplication([], True)
#removing old layers
QgsMapLayerRegistry.instance().removeAllMapLayers()

script_folder = os.path.dirname(__file__)
project_folder = os.path.dirname(script_folder)
output_folder = os.path.join(project_folder, 'map_outputs')
xml_folder = os.path.join(project_folder, 'project_outputs')
shapefile_folder = os.path.join(project_folder, 'shapefile_folder')

template_composer = os.path.join(project_folder, 'basic_composer_template.qpt')
polyg_shapefile = os.path.join(shapefile_folder, 'polygon.shp')
point_shapefile = os.path.join(shapefile_folder, 'point.shp') 

mapname = "Test Map"
srid = 4326
provider_name = 'ogr'
layerset = []

#add layer 1
vlayer_name= 'polygon layer'
vdata_source = polyg_shapefile
print "Loading EQ buffers"
layer = QgsVectorLayer(vdata_source, vlayer_name, provider_name)
print "Buffers loaded"
QgsMapLayerRegistry.instance().addMapLayer(layer)
layerset.append(layer.id())

#add layer 2
point_layer_name= 'point layer'
point_data_source = point_shapefile
point_layer = QgsVectorLayer(point_data_source, point_layer_name, provider_name)
QgsMapLayerRegistry.instance().addMapLayer(point_layer)
layerset.append(point_layer.id())

# Set up the MapSetting object that will be assigned to the composition
ms = QgsMapSettings()
#preparing the map the extent - 3 times wider than the polygon layer's extent
rect = layer.extent()
rect.scale(3)

# Enable on the fly CRS transformations
ms.setCrsTransformEnabled(True)

composition = QgsComposition(ms)
#set WGS84 as destination crs
map_projection = QgsCoordinateReferenceSystem(srid,             QgsCoordinateReferenceSystem.PostgisCrsId)
map_projection_descr = map_projection.description()
ms.setDestinationCrs(map_projection)

#open the composer template and edit it
with open(template_composer, 'r') as f:
    tree  = etree.parse(f)
    #setting extent
    for elem in tree.iter(tag = 'Extent'):
        elem.attrib['xmax'] = str(rect.xMaximum())
        elem.attrib['xmin'] = str(rect.xMinimum())
        elem.attrib['ymax'] = str(rect.yMaximum())
        elem.attrib['ymin'] = str(rect.yMinimum())
    #editing the title
    for elem in tree.iter(tag = 'ComposerLabel'):
            for child in elem:
                if child.tag == 'ComposerItem':
                    if child.attrib['id'] == "__maintitle__":
                        elem.attrib['labelText'] = mapname
    #save the edited composer as a new file
    new_composer = os.path.join(xml_folder, mapname + "_composer.qpt")
    tree.write(new_composer)

#open the newly created composer
new_composerfile = file(new_composer, 'rt')
new_composer_content = new_composerfile.read()
new_composerfile.close()
document = QDomDocument()
document.setContent(new_composer_content)
result = composition.loadFromTemplate(document)

# Get the main map canvas on the composition and set the layers
composerMap = composition.getComposerMapById(0)
composerMap.renderModeUpdateCachedImage()
ms.setLayers(layerset)

#legend
legend = QgsComposerLegend(composition)
legend.model().setLayerSet(ms.layers())
legend.model().setLayerSet
composition.addItem(legend)
legend.setItemPosition (25,122)
legend.setFrameEnabled(True)
legend.setScale(.7)

#save image
print 'saving image'
image = composition.printPageAsRaster(0)
image.save(os.path.join(output_folder,mapname) + ".png")

PyQGIS Script – Refreshing MapCanvas While Running

Sleep blocks the execution of your script for a while, synchronously.

One solution for your question is to use a QTimer, which controls when to execute functions and it's asynchronous, i.e., it allows other functions to continue to run (think of a map.refresh()) while waiting some milliseconds to run the next instruction.

Have a look at How to iterate over layers and export them as PNG images with PyQGIS in a standalone script for an implemented example that is similar to your case.

There are two functions, one to prepare the map (in your case, set the new extent and refresh the map) and another one to export the map. After the map is prepared, a QTimer is set to wait 1 second before calling exportMap(). Such second gives enough time for the map to reflect changes and be ready to be exported:

QTimer.singleShot(1000, exportMap)

Best Answer

Related Solutions

PyQGIS – Making Serial Maps from Template

PyQGIS Script – Refreshing MapCanvas While Running

Related Question