run Points in Polygon in separate thread and don't block QGIS main

window (addresses #5162)

Author: alexbruy

python/plugins/fTools/fTools.py

@@ -450,6 +450,7 @@ def dosumLines(self):
 
   def dopointsPoly(self):
     d = doPointsInPolygon.Dialog(self.iface)
+    d.show()
     d.exec_()
 
   def dorandSel(self):

python/plugins/fTools/tools/doPointsInPolygon.py

@@ -39,11 +39,13 @@ class Dialog(QDialog, Ui_Dialog):
     def __init__(self, iface):
         QDialog.__init__(self, iface.mainWindow())
         self.iface = iface
-        # Set up the user interface from Designer.
         self.setupUi(self)
-        QObject.connect(self.toolOut, SIGNAL("clicked()"), self.outFile)
+
         self.setWindowTitle(self.tr("Count Points in Polygon"))
-        self.buttonOk = self.buttonBox_2.button( QDialogButtonBox.Ok )
+        self.btnOk = self.buttonBox.button( QDialogButtonBox.Ok )
+        self.btnClose = self.buttonBox.button( QDialogButtonBox.Close )
+
+        QObject.connect(self.toolOut, SIGNAL("clicked()"), self.outFile)
         self.progressBar.setValue(0)
         self.populateLayers()
 
@@ -56,93 +58,193 @@ def populateLayers( self ):
         layers = ftools_utils.getLayerNames([QGis.Point])
         self.inPoint.addItems(layers)
 
+    def outFile(self):
+        self.outShape.clear()
+        (self.shapefileName, self.encoding) = ftools_utils.saveDialog(self)
+        if self.shapefileName is None or self.encoding is None:
+            return
+        self.outShape.setText(QString(self.shapefileName))
+
     def accept(self):
-        self.buttonOk.setEnabled( False )
         if self.inPolygon.currentText() == "":
-            QMessageBox.information(self, self.tr("Count Points In Polygon"), self.tr("Please specify input polygon vector layer"))
-        elif self.outShape.text() == "":
-            QMessageBox.information(self, self.tr("Count Points In Polygon"), self.tr("Please specify output shapefile"))
+            QMessageBox.information(self, self.tr("Count Points In Polygon"),
+                                    self.tr("Please specify input polygon vector layer"))
         elif self.inPoint.currentText() == "":
-            QMessageBox.information(self, self.tr("Count Points In Polygon"), self.tr("Please specify input point vector layer"))
+            QMessageBox.information(self, self.tr("Count Points In Polygon"),
+                                    self.tr("Please specify input point vector layer"))
         elif self.lnField.text() == "":
-            QMessageBox.information(self, self.tr("Count Points In Polygon"), self.tr("Please specify output count field"))
+            QMessageBox.information(self, self.tr("Count Points In Polygon"),
+                                    self.tr("Please specify output count field"))
+        elif self.outShape.text() == "":
+            QMessageBox.information(self, self.tr("Count Points In Polygon"),
+                                    self.tr("Please specify output shapefile"))
         else:
-            inPoly = self.inPolygon.currentText()
-            inPts = self.inPoint.currentText()
-            inField = self.lnField.text()
-            outPath = self.outShape.text()
-            if outPath.contains("\\"):
-                outName = outPath.right((outPath.length() - outPath.lastIndexOf("\\")) - 1)
-            else:
-                outName = outPath.right((outPath.length() - outPath.lastIndexOf("/")) - 1)
-            if outName.endsWith(".shp"):
-                outName = outName.left(outName.length() - 4)
-            self.compute(inPoly, inPts, inField, outPath, self.progressBar)
-            self.outShape.clear()
-            addToTOC = QMessageBox.question(self, self.tr("Count Points in Polygon"), self.tr("Created output shapefile:\n%1\n\nWould you like to add the new layer to the TOC?").arg(unicode(outPath)), QMessageBox.Yes, QMessageBox.No, QMessageBox.NoButton)
-            if addToTOC == QMessageBox.Yes:
-                self.vlayer = QgsVectorLayer(outPath, unicode(outName), "ogr")
-                QgsMapLayerRegistry.instance().addMapLayer(self.vlayer)
-                self.populateLayers()
+            inPoly = ftools_utils.getVectorLayerByName(self.inPolygon.currentText())
+            inPnts = ftools_utils.getVectorLayerByName(self.inPoint.currentText())
+
+            polyProvider = inPoly.dataProvider()
+            pointProvider = inPnts.dataProvider()
+            if polyProvider.crs() <> pointProvider.crs():
+                QMessageBox.warning(self, self.tr("CRS warning!"),
+                                    self.tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results."))
+
+            self.btnOk.setEnabled(False)
+
+            self.workThread = PointsInPolygonThread(inPoly, inPnts, self.lnField.text(), self.outShape.text(), self.encoding)
+
+            QObject.connect(self.workThread, SIGNAL("rangeChanged(int)"), self.setProgressRange)
+            QObject.connect(self.workThread, SIGNAL("updateProgress()"), self.updateProgress)
+            QObject.connect(self.workThread, SIGNAL("processingFinished()"), self.processFinished)
+            QObject.connect(self.workThread, SIGNAL("processingInterrupted()"), self.processInterrupted)
+
+            self.btnClose.setText(self.tr("Cancel"))
+            QObject.disconnect(self.buttonBox, SIGNAL("rejected()"), self.reject)
+            QObject.connect(self.btnClose, SIGNAL("clicked()"), self.stopProcessing)
+
+            self.workThread.start()
+
+    def setProgressRange(self, maxValue):
+        self.progressBar.setRange(0, maxValue)
         self.progressBar.setValue(0)
-        self.buttonOk.setEnabled( True )
 
-    def outFile(self):
+    def updateProgress(self):
+        self.progressBar.setValue(self.progressBar.value() + 1)
+
+    def processFinished(self):
+        self.stopProcessing()
+
+        addToTOC = QMessageBox.question(self, self.tr("Count Points in Polygon"),
+                                        self.tr("Created output shapefile:\n%1\n\nWould you like to add the new layer to the TOC?").arg(self.outShape.text()),
+                                        QMessageBox.Yes, QMessageBox.No, QMessageBox.NoButton)
+        if addToTOC == QMessageBox.Yes:
+            fileInfo = QFileInfo( self.outShape.text() )
+            layerName = fileInfo.completeBaseName()
+            layer = QgsVectorLayer(self.outShape.text(), layerName, "ogr")
+            QgsMapLayerRegistry.instance().addMapLayer(layer)
+            self.populateLayers()
+
+        self.restoreGui()
+
+    def processInterrupted(self):
+        self.restoreGui()
+
+    def stopProcessing(self):
+        if self.workThread != None:
+            self.workThread.stop()
+            self.workThread = None
+
+    def restoreGui(self):
+        self.progressBar.setRange(0, 1)
+        self.progressBar.setValue(0)
         self.outShape.clear()
-        ( self.shapefileName, self.encoding ) = ftools_utils.saveDialog( self )
-        if self.shapefileName is None or self.encoding is None:
-            return
-        self.outShape.setText( QString( self.shapefileName ) )
-
-    def compute(self, inPoly, inPts, inField, outPath, progressBar):
-        polyLayer = ftools_utils.getVectorLayerByName(inPoly)
-        pointLayer = ftools_utils.getVectorLayerByName(inPts)
-        polyProvider = polyLayer.dataProvider()
-        pointProvider = pointLayer.dataProvider()
-        if polyProvider.crs() <> pointProvider.crs():
-            QMessageBox.warning(self, self.tr("CRS warning!"), self.tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results."))
+
+        QObject.disconnect(self.btnClose, SIGNAL("clicked()"), self.stopProcessing)
+        QObject.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
+        self.btnClose.setText(self.tr("Close"))
+        self.btnOk.setEnabled(True)
+
+class PointsInPolygonThread(QThread):
+    def __init__( self, inPoly, inPoints, fieldName, outPath, encoding ):
+        QThread.__init__( self, QThread.currentThread() )
+        self.mutex = QMutex()
+        self.stopMe = 0
+        self.interrupted = False
+
+        self.layerPoly = inPoly
+        self.layerPoints = inPoints
+        self.fieldName = fieldName
+        self.outPath = outPath
+        self.encoding = encoding
+
+    def run(self):
+        self.mutex.lock()
+        self.stopMe = 0
+        self.mutex.unlock()
+
+        interrupted = False
+
+        polyProvider = self.layerPoly.dataProvider()
+        pointProvider = self.layerPoints.dataProvider()
+
         allAttrs = polyProvider.attributeIndexes()
         polyProvider.select(allAttrs)
-        allAttrs = pointProvider.attributeIndexes()
-        pointProvider.select(allAttrs)
-        fieldList = ftools_utils.getFieldList(polyLayer)
-        index = polyProvider.fieldNameIndex(unicode(inField))
+
+        fieldList = ftools_utils.getFieldList(self.layerPoly)
+        index = polyProvider.fieldNameIndex(unicode(self.fieldName))
         if index == -1:
             index = polyProvider.fieldCount()
-            field = QgsField(unicode(inField), QVariant.Double, "real", 24, 15, self.tr("point count field"))
+            field = QgsField(unicode(self.fieldName), QVariant.Double, "real", 24, 15, self.tr("point count field"))
             fieldList[index] = field
+
         sRs = polyProvider.crs()
-        check = QFile(self.shapefileName)
-        if check.exists():
-            if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName):
+        if QFile(self.outPath).exists():
+            if not QgsVectorFileWriter.deleteShapeFile(self.outPath):
                 return
-        writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, polyProvider.geometryType(), sRs)
-        inFeat = QgsFeature()
-        inFeatB = QgsFeature()
+
+        writer = QgsVectorFileWriter(self.outPath, self.encoding, fieldList,
+                                     polyProvider.geometryType(), sRs)
+
+        spatialIndex = ftools_utils.createIndex( pointProvider )
+        pointProvider.rewind()
+        pointProvider.select()
+
+        self.emit(SIGNAL("rangeChanged(int)"), polyProvider.featureCount() )
+
+        polyFeat = QgsFeature()
+        pntFeat = QgsFeature()
         outFeat = QgsFeature()
         inGeom = QgsGeometry()
-        start = 15.00
-        add = 85.00 / polyProvider.featureCount()
-        spatialIndex = ftools_utils.createIndex( pointProvider )
-        while polyProvider.nextFeature(inFeat):
-            inGeom = inFeat.geometry()
-            atMap = inFeat.attributeMap()
+        while polyProvider.nextFeature(polyFeat):
+            inGeom = polyFeat.geometry()
+            atMap = polyFeat.attributeMap()
             outFeat.setAttributeMap(atMap)
             outFeat.setGeometry(inGeom)
-            pointList = []
+
             count = 0
+            pointList = []
+            hasIntersection = True
             pointList = spatialIndex.intersects(inGeom.boundingBox())
-            if len(pointList) > 0: check = 0
-            else: check = 1
-            if check == 0:
-                for i in pointList:
-                    pointProvider.featureAtId( int( i ), inFeatB , True, allAttrs )
-                    tmpGeom = QgsGeometry( inFeatB.geometry() )
-                    if inGeom.intersects( tmpGeom ):
-                        count = count + 1
-            outFeat.setAttributeMap(atMap)
+            if len(pointList) > 0:
+                hasIntersection = True
+            else:
+                hasIntersection = False
+
+            if hasIntersection:
+                for p in pointList:
+                    pointProvider.featureAtId(p, pntFeat , True)
+                    tmpGeom = QgsGeometry(pntFeat.geometry())
+                    if inGeom.intersects(tmpGeom):
+                        count += 1
+
+                    self.mutex.lock()
+                    s = self.stopMe
+                    self.mutex.unlock()
+                    if s == 1:
+                        interrupted = True
+                        break
+
             outFeat.addAttribute(index, QVariant(count))
             writer.addFeature(outFeat)
-            start = start + 1
-            progressBar.setValue(start)
+
+            self.emit( SIGNAL( "updateProgress()" ) )
+
+            self.mutex.lock()
+            s = self.stopMe
+            self.mutex.unlock()
+            if s == 1:
+                interrupted = True
+                break
+
         del writer
+
+        if not interrupted:
+            self.emit( SIGNAL( "processingFinished()" ) )
+        else:
+            self.emit( SIGNAL( "processingInterrupted()" ) )
+
+    def stop(self):
+        self.mutex.lock()
+        self.stopMe = 1
+        self.mutex.unlock()
+
+        QThread.wait( self )

python/plugins/fTools/tools/doSelectByLocation.py

@@ -41,7 +41,7 @@ def __init__(self, iface):
         self.iface = iface
         # Set up the user interface from Designer.
         self.setupUi(self)
-        self.buttonOk = self.buttonBox_2.button( QDialogButtonBox.Ok )
+        self.buttonOk = self.buttonBox.button( QDialogButtonBox.Ok )
         # populate layer list
         self.progressBar.setValue(0)
         mapCanvas = self.iface.mapCanvas()