def run_geoprocessing_ctrl(self):
self.geo_ctrl = GeoprocessingGui(self.iface.mainWindow())
QObject.connect(self.geo_ctrl, SIGNAL("geoprocessingSignal(QString, QString, QString, QString, int, int, bool, bool)"), self.geoprocessing)
QObject.connect(self.geo_ctrl, SIGNAL("functionChanged(QString)"), self.manageGui)
QObject.connect(self.geo_ctrl, SIGNAL("layerAChanged(QString)"), self.addSpecialAttributes)
QObject.connect(self.geo_ctrl, SIGNAL("layerAChanged(QString)"), self.checkBtnOK)
QObject.connect(self.geo_ctrl, SIGNAL("showAbout()"), self.about)
self.geo_ctrl.show()
class Geoprocessing:
def __init__(self, iface):
# save reference to the QGIS interface
self.iface = iface
self.QgisVersion = str(QGis.QGIS_VERSION)
userPluginPath = QFileInfo(QgsApplication.qgisUserDbFilePath()).path()+"/python/plugins/geoprocessing"
systemPluginPath = QgsApplication.prefixPath()+"/share/qgis/python/plugins/geoprocessing"
myLocaleName = QLocale.system().name()
myLocale = myLocaleName[0:2]
if QFileInfo(userPluginPath).exists():
pluginPath = userPluginPath+"/i18n/geoprocessing_"+myLocale+".qm"
elif QFileInfo(systemPluginPath).exists():
pluginPath = systemPluginPath+"/i18n/geoprocessing_"+myLocale+".qm"
self.localePath = pluginPath
if QFileInfo(self.localePath).exists():
self.translator = QTranslator()
self.translator.load(self.localePath)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Error Messages
self.topoErrorMessage = QCoreApplication.translate("Geoprocessing","Resulting Geometry is not valid due to topology errors "
+"caused by invalid input geometries or GEOS topology exceptions during process!\n\n"
+"The resulting geometry probably will not show the correct results.\n"
+"Try to clean your input geometries.")
self.versionMessage = QCoreApplication.translate("Geoprocessing","Quantum GIS version detected: "+str(self.QgisVersion)+"\n"
+"Geoprocessing plugin requires version at least 1.0.0!\n"
+"Plugin not loaded.")
def initGui(self):
# check Qgis Version
if int(self.QgisVersion[0]) < 1:
if (int(self.QgisVersion[2]) >= 7 and int(self.QgisVersion[2]) <= 9):
QMessageBox.warning(None, "Version", self.versionMessage)
return 1
# create action that will start plugin configuration
self.actionGeoprocessing = QAction(QIcon(":/plugins/geoprocessing/icon_buffer.xpm"), QCoreApplication.translate("Geoprocessing","Geoprocessing Tool"), self.iface.mainWindow())
QObject.connect(self.actionGeoprocessing, SIGNAL("triggered()"), self.run_geoprocessing_ctrl)
# Create about button
#self.aboutaction = QAction(QIcon(":/plugins/geoprocessing/about.png"), "About", self.iface.mainWindow())
#self.aboutaction.setWhatsThis("About Geoprocessing")
#QObject.connect(self.aboutaction, SIGNAL("activated()"), self.about)
# add toolbar buttons
self.toolbar = self.iface.addToolBarIcon(self.actionGeoprocessing)
self.iface.addPluginToMenu("&Geoprocessing", self.actionGeoprocessing)
#self.iface.addPluginToMenu("Geoprocessing", self.aboutaction)
def about(self):
infoString = QString(QCoreApplication.translate("Geoprocessing","Population Density Gradient Plugin\n"
+ "The Plugin provides a standardized way to analyze the population density gradient of cities.\n"
+ "Author: David Quinn\n"
+ "Mail: [email protected]"))
QMessageBox.information(self.iface.mainWindow(), "About PopDenGradient",infoString)
def unload(self):
# remove the toolbar and the menu
self.iface.removePluginMenu("&Geoprocessing", self.actionGeoprocessing)
self.iface.removeToolBarIcon(self.actionGeoprocessing)
def run_geoprocessing_ctrl(self):
self.geo_ctrl = GeoprocessingGui(self.iface.mainWindow())
QObject.connect(self.geo_ctrl, SIGNAL("geoprocessingSignal(QString, QString, QString, QString, int, int, bool, bool)"), self.geoprocessing)
QObject.connect(self.geo_ctrl, SIGNAL("functionChanged(QString)"), self.manageGui)
QObject.connect(self.geo_ctrl, SIGNAL("layerAChanged(QString)"), self.addSpecialAttributes)
QObject.connect(self.geo_ctrl, SIGNAL("layerAChanged(QString)"), self.checkBtnOK)
QObject.connect(self.geo_ctrl, SIGNAL("showAbout()"), self.about)
self.geo_ctrl.show()
def isValidGeometry(self, fet):
try:
if fet.geometry().wkbSize() > 0:
return True
except:
if self.message == False:
QMessageBox.warning(None, QCoreApplication.translate("Geoprocessing","Error"), self.topoErrorMessage)
self.message = True
return False
def writerErrorMessage(self, errorNum):
if errorNum == 1:
return QCoreApplication.translate("Geoprocessing","Driver not found")
elif errorNum == 2:
return QCoreApplication.translate("Geoprocessing","Error while creating datasource")
elif errorNum == 3:
return QCoreApplication.translate("Geoprocessing","Error while creating layer")
elif errorNum == 4:
return QCoreApplication.translate("Geoprocessing","Input layer has not supported column types")
def checkBtnOK(self, lyerName):
if self.geo_ctrl.cmbLayerA.currentIndex() > 0:
self.geo_ctrl.btnOk.setEnabled(True)
return 0
# Add Attributes of Layer A to the non working Item Attribute chkBox for Buffer-Item and Dissolve Item
#TODO apply this functionality
def addSpecialAttributes(self, layerName):
if self.geo_ctrl.cmbLayerA.currentIndex() > 0 and self.geo_ctrl.cmbFunction.currentIndex()==4:
vLayer = self.getVectorLayerByName(layerName)
self.geo_ctrl.cmbAttribA.clear()
itemList = []
itemList.append(QCoreApplication.translate("Geoprocessing","select an Item"))
self.geo_ctrl.cmbAttribA.addItems(itemList)
self.geo_ctrl.cmbAttribA.addItems(self.getFieldNames(vLayer))
self.geo_ctrl.cmbAttribA.setEnabled(True)
return 0
# Dynamic configuration of geoprocessing GUI
# Buffer => 1
# Convex Hull => 2
# Difference A - B => 3
# Dissolve => 4
# Intersection => 5
# Union => 6
# SymDifference => 99
def manageGui(self, myFunction):
self.geo_ctrl.chkBoxSelectedFeatures.setText(QCoreApplication.translate("Geoprocessing","Dissolve Buffer Result"))
self.geo_ctrl.label_6.setText(QCoreApplication.translate("Geoprocessing","Maximum Radius [km]:"))
self.geo_ctrl.lblItems.setText(QCoreApplication.translate("Geoprocessing","Buffer Item"))
self.geo_ctrl.lblItems.setEnabled(False)
self.geo_ctrl.label_6.setEnabled(False)
if self.geo_ctrl.cmbFunction.currentIndex() == 1:
self.geo_ctrl.label_2.setEnabled(True)
self.geo_ctrl.cmbLayerA.setEnabled(True)
self.geo_ctrl.label_6.setEnabled(True)
self.geo_ctrl.lblItems.setEnabled(False)
self.geo_ctrl.lineEditParameter.setEnabled(True)
self.geo_ctrl.label.setEnabled(False)
self.geo_ctrl.cmbLayerB.setEnabled(False)
self.geo_ctrl.cmbAttribA.setEnabled(True)
self.geo_ctrl.chkBoxSelectedFeatures.setEnabled(True)
self.geo_ctrl.chkBoxAddShape.setEnabled(True)
self.geo_ctrl.label_3.setEnabled(True)
self.geo_ctrl.lineEditShapeDir.setEnabled(True)
self.geo_ctrl.btnBrowse.setEnabled(True)
elif self.geo_ctrl.cmbFunction.currentIndex() == 4:
self.geo_ctrl.label_2.setEnabled(True)
self.geo_ctrl.cmbLayerA.setEnabled(True)
self.geo_ctrl.label_6.setEnabled(False)
self.geo_ctrl.lineEditParameter.setEnabled(False)
self.geo_ctrl.label.setEnabled(False)
self.geo_ctrl.cmbLayerB.setEnabled(False)
self.geo_ctrl.lblItems.setEnabled(True)
self.geo_ctrl.lblItems.setText(QCoreApplication.translate("Geoprocessing","Dissolve Item"))
self.geo_ctrl.cmbAttribA.setEnabled(True)
self.geo_ctrl.chkBoxSelectedFeatures.setEnabled(False)
self.geo_ctrl.chkBoxAddShape.setEnabled(True)
elif self.geo_ctrl.cmbFunction.currentIndex() == 2:
self.geo_ctrl.label_2.setEnabled(True)
self.geo_ctrl.cmbLayerA.setEnabled(True)
self.geo_ctrl.label_6.setEnabled(False)
self.geo_ctrl.lineEditParameter.setEnabled(False)
self.geo_ctrl.label.setEnabled(False)
self.geo_ctrl.cmbLayerB.setEnabled(False)
self.geo_ctrl.lblItems.setEnabled(False)
self.geo_ctrl.cmbAttribA.setEnabled(False)
self.geo_ctrl.chkBoxSelectedFeatures.setEnabled(False)
self.geo_ctrl.chkBoxAddShape.setEnabled(True)
elif self.geo_ctrl.cmbFunction.currentIndex() == 3:
self.geo_ctrl.label_2.setEnabled(True)
self.geo_ctrl.cmbLayerA.setEnabled(True)
self.geo_ctrl.label_6.setEnabled(False)
self.geo_ctrl.lineEditParameter.setEnabled(False)
self.geo_ctrl.label.setEnabled(True)
self.geo_ctrl.cmbLayerB.setEnabled(True)
self.geo_ctrl.lblItems.setEnabled(False)
self.geo_ctrl.cmbAttribA.setEnabled(False)
self.geo_ctrl.chkBoxSelectedFeatures.setEnabled(False)
self.geo_ctrl.chkBoxAddShape.setEnabled(True)
else:
self.geo_ctrl.label_2.setEnabled(True)
self.geo_ctrl.cmbLayerA.setEnabled(True)
self.geo_ctrl.label_6.setEnabled(False)
self.geo_ctrl.label.setEnabled(True)
self.geo_ctrl.cmbLayerB.setEnabled(True)
self.geo_ctrl.lblItems.setEnabled(False)
self.geo_ctrl.cmbAttribA.setEnabled(True)
self.geo_ctrl.lineEditParameter.setEnabled(False)
self.geo_ctrl.chkBoxSelectedFeatures.setEnabled(False)
self.geo_ctrl.chkBoxAddShape.setEnabled(True)
self.geo_ctrl.label_3.setEnabled(True)
self.geo_ctrl.btnOk.setEnabled(False)
self.geo_ctrl.label_3.setEnabled(True)
self.geo_ctrl.lineEditShapeDir.setEnabled(True)
self.geo_ctrl.btnBrowse.setEnabled(True)
self.geo_ctrl.chkBoxAddShape.setEnabled(True)
self.geo_ctrl.cmbAttribA.setEnabled(False)
myListA = []
myListB = []
self.geo_ctrl.cmbLayerA.clear()
self.geo_ctrl.cmbLayerB.clear()
if self.geo_ctrl.cmbFunction.currentIndex()==5:
myListA = self.getLayerNames("all")
myListB = self.getLayerNames("Polygon")
elif self.geo_ctrl.cmbFunction.currentIndex()==7:
myListA = self.getLayerNames("all")
myListB = self.getLayerNames("all")
elif self.geo_ctrl.cmbFunction.currentIndex()==3:
myListA = self.getLayerNames("Polygon")
myListB = self.getLayerNames("Polygon")
elif self.geo_ctrl.cmbFunction.currentIndex()==6:
myListA = self.getLayerNames("Polygon")
myListB = self.getLayerNames("Polygon")
elif self.geo_ctrl.cmbFunction.currentIndex()==99:
myListA = self.getLayerNames("Polygon")
myListB = self.getLayerNames("Polygon")
elif self.geo_ctrl.cmbFunction.currentIndex()==4:
myListA = self.getLayerNames("Polygon")
myListB = self.getLayerNames("Polygon")
self.geo_ctrl.cmbAttribA.clear()
else:
myListA = self.getLayerNames("all")
myListB = self.getLayerNames("all")
emptyString = []
emptyString.append("---------")
self.geo_ctrl.cmbLayerA.addItems(emptyString)
self.geo_ctrl.cmbLayerB.addItems(emptyString)
self.geo_ctrl.cmbLayerA.addItems(myListA)
self.geo_ctrl.cmbLayerB.addItems(myListB)
return 0
def geoprocessing(self, myLayerA, myLayerB, myParam, myPath, myFunction, attribID, myBool, mergeBool):
# Difference A - B
if myFunction == 3:
self.difference(myLayerA, myLayerB, myPath, myBool)
# Buffer
elif myFunction == 1:
self.buffering(myLayerA, myParam, myPath, myBool, mergeBool)
# Intersection
elif myFunction == 5:
self.intersection(myLayerA, myLayerB, myPath, myBool)
# SymDifference
elif myFunction == 99:
self.symDifference(myLayerA, myLayerB, myPath, myBool)
# Union
elif myFunction == 6:
self.union(myLayerA, myLayerB, myPath, myBool)
# Convex Hull
elif myFunction == 2:
self.convexHull(myLayerA, myPath, myBool)
# Dissolve
elif myFunction == 4:
self.dissolve(myLayerA, myPath, myBool, attribID)
# Merge equal structured Layer
elif myFunction == 7:
self.merge(myLayerA, myLayerB, myPath, myBool)
#Preparation of the Union Process
#TODO: union is not working until now but can be substituted by intersection
def union(self, myLayerA, myLayerB, myPath, myBool):
vlayerA = self.getVectorLayerByName(myLayerA)
vlayerB = self.getVectorLayerByName(myLayerB)
fieldList = self.mergeFields(vlayerA, vlayerB)
shapeFilePath = self.createShapeFileName(vlayerA, myPath, "union", )
writer = self.createShapeFileWriter(shapeFilePath, fieldList, vlayerA.dataProvider().geometryType())
if writer==0:
return 0
resultList = self.makeUnion(vlayerA, vlayerB)
for fet in resultList:
writer.addFeature(fet)
# mLayer.addFeature(fet)
del writer
# add the new Shape to the map canvas
if myBool:
self.addShapeToCanvas(shapeFilePath)
self.geo_ctrl.close()
def merge(self, myLayerA, myLayerB, myPath, myBool):
vlayerA = self.getVectorLayerByName(myLayerA)
vlayerB = self.getVectorLayerByName(myLayerB)
fieldList = self.getFieldList(vlayerA)
shapeFilePath = self.createShapeFileName(vlayerA, myPath, "merge", )
writer = self.createShapeFileWriter(shapeFilePath, fieldList, vlayerA.dataProvider().geometryType())
if writer==0:
return 0
resultList = self.makeMerge(vlayerA, vlayerB)
for fet in resultList:
writer.addFeature(fet)
del writer
# add the new Shape to the map canvas
if myBool:
self.addShapeToCanvas(shapeFilePath)
self.geo_ctrl.close()
def intersection(self, myLayerA, myLayerB, myPath, myBool, virtual=False):
vlayerA = self.getVectorLayerByName(myLayerA)
vlayerB = self.getVectorLayerByName(myLayerB)
fieldList = self.mergeFields(vlayerA, vlayerB)
shapeFilePath = self.createShapeFileName(vlayerA, myPath, "intersection", )
writer = self.createShapeFileWriter(shapeFilePath, fieldList, vlayerA.dataProvider().geometryType())
if writer==0:
return 0
resultList = self.makeIntersection(vlayerA, vlayerB)
for fet in resultList:
writer.addFeature(fet)
# delete the writer to flush features to disk (optional)
del writer
# add the new Shape to the map canvas
if myBool:
self.addShapeToCanvas(shapeFilePath)
self.geo_ctrl.close()
def convexHull(self, myLayer, myPath, myBool):
vlayer = self.getVectorLayerByName(myLayer)
provider = vlayer.dataProvider()
feat = QgsFeature()
allAttrs = provider.attributeIndexes()
provider.select(allAttrs)
shapeFilePath = self.createShapeFileName(vlayer, myPath, "convexHull", )
fieldList = self.getFeatureList(vlayer)
writer = self.createShapeFileWriter(shapeFilePath, fieldList, QGis.WKBPolygon)
if writer==0:
return 0
# while provider.getNextFeature(feat):
hullGeo = self.singleToMulti(vlayer)
hullResult = hullGeo.convexHull()
fet = QgsFeature()
fet.setGeometry(hullResult)
fet.addAttribute(0, QVariant(1))
writer.addFeature(fet)
# delete the writer to flush features to disk (optional)
del writer
# add the new Shape to the map canvas
if myBool:
self.addShapeToCanvas(shapeFilePath)
self.geo_ctrl.close()
def dissolve(self, myLayerA, myPath, myBool, attribID=0, virtual=False):
attribName = self.geo_ctrl.cmbAttribA.itemText(attribID)
vlayerA = self.getVectorLayerByName(myLayerA)
fieldList = self.getFeatureList(vlayerA)
# mLayer = self.createMemoryLayer("POLYGON","test",fieldList)
shapeFilePath = self.createShapeFileName(vlayerA, myPath, "dissolve", )
writer = self.createShapeFileWriter(shapeFilePath, fieldList, vlayerA.dataProvider().geometryType())
if writer==0:
return 0
nFeat = vlayerA.dataProvider().featureCount()
self.nElement = 0
self.geo_ctrl.progressBar.setValue(0)
self.geo_ctrl.progressBar.setRange(0, nFeat)
if attribID > 0:
featureList = self.getFeatureList(vlayerA)
fieldID = vlayerA.dataProvider().fieldNameIndex(attribName)
attribValueList = self.getUniqueAttributeValues(vlayerA, fieldID)
for attr in attribValueList:
dissResult = self.makeDissolve(vlayerA, fieldID, attr)
for fet in dissResult:
writer.addFeature(fet)
else:
dissResult = self.makeDissolve(vlayerA)
for fet in dissResult:
writer.addFeature(fet)
# delete the writer to flush features to disk (optional)
del writer
# add the new Shape to the map canvas
if myBool:
self.addShapeToCanvas(shapeFilePath)
self.geo_ctrl.close()
def difference(self, myLayerA, myLayerB, myPath, myBool):
vlayerA = self.getVectorLayerByName(myLayerA)
vlayerB = self.getVectorLayerByName(myLayerB)
self.mergeFields(vlayerA, vlayerB)
fieldList = self.getFeatureList(vlayerA)
shapeFilePath = self.createShapeFileName(vlayerA, myPath, "difference", )
writer = self.createShapeFileWriter(shapeFilePath, fieldList, vlayerA.dataProvider().geometryType())
if writer==0:
return 0
diffResult = self.makeDifference(vlayerA, vlayerB)
for fet in diffResult:
writer.addFeature(fet)
# delete the writer to flush features to disk (optional)
del writer
# add the new Shape to the map canvas
if myBool:
self.addShapeToCanvas(shapeFilePath)
self.geo_ctrl.close()
#TODO is not working until now
def symDifference(self, myLayerA, myLayerB, myPath, myBool):
vlayerA = self.getVectorLayerByName(myLayerA)
vlayerB = self.getVectorLayerByName(myLayerB)
fieldList = self.getFeatureList(vlayerA)
shapeFilePath = self.createShapeFileName(vlayerA, myPath, "symdifference", )
writer = self.createShapeFileWriter(shapeFilePath, fieldList, vlayerA.dataProvider().geometryType())
if writer==0:
return 0
self.makeSymDifference(writer,vlayerA, vlayerB)
# delete the writer to flush features to disk (optional)
del writer
# add the new Shape to the map canvas
if myBool:
self.addShapeToCanvas(shapeFilePath)
self.geo_ctrl.close()
def buffering(self, myLayer, bufferDistance, myPath, myBool, mergeBool):
vlayer = self.getVectorLayerByName(myLayer)
provider = vlayer.dataProvider()
fieldList = self.getFeatureList(vlayer)
allAttrs = provider.attributeIndexes()
provider.select(allAttrs)
shapeFilePath = self.createShapeFileName(vlayer, myPath, "buffer", )
if mergeBool or self.geo_ctrl.cmbAttribA.currentIndex() > 0:
writer = self.createShapeFileWriter(shapeFilePath, fieldList, QGis.WKBMultiPolygon)
if writer==0:
return 0
else:
writer = self.createShapeFileWriter(shapeFilePath, fieldList, QGis.WKBPolygon)
if writer==0:
return 0
bufferResult = self.makeBuffer(provider, mergeBool, bufferDistance)
for fet in bufferResult:
writer.addFeature(fet)
# delete the writer to flush features to disk (optional)
del writer
# add the new Shape to the map canvas
if myBool:
self.addShapeToCanvas(shapeFilePath)
self.geo_ctrl.close()
return 0
# def createMemoryLayer(layerType, layerName, fieldList):
# create layer
# vl = QgsVectorLayer(layerType, layerName, "memory")
# pr = vl.getDataProvider()
# add fields
# to preserve correct order they must be added one-by-one (d'oh)
# print fieldList
# return 0
# for att in fieldList:
# pr.addAttributes( att )
# return vl
#Gets Layernames from canvas
#Return: List of Layernames
def getLayerNames(self, vectorType):
mc=self.iface.mapCanvas()
nLayers=mc.layerCount()
layerNamesList = []
if vectorType=="all":
myType=0
elif vectorType=="Polygon":
myType=2
for l in range(nLayers):
layer = mc.layer(l)
if layer.type() == QgsMapLayer.VectorLayer and layer.geometryType() >= myType and not layer.name() in layerNamesList:
layerNamesList.append(unicode(layer.name(),'latin1'))
return layerNamesList
# Gets Vector Layer by Layername in canvas
#Return: QgsVectorLayer
def getVectorLayerByName(self, myName):
mc=self.iface.mapCanvas()
nLayers=mc.layerCount()
for l in range(nLayers):
layer = mc.layer(l)
if layer.name() == unicode(myName,'latin1'):
if(unicode(layer.source(),'latin1').lower().find("host=") > 0):
# it's a postgis-layer
providerName = "postgres"
elif(unicode(layer.source(),'latin1').lower().find(".shp") > 0):
# it's a shape-layer
providerName = "ogr"
else:
QMessageBox.error(None, "Meldung", "Kein Provider gefunden!")
# wie schliess ich hier eben das Plugin generisch?
vlayer = QgsVectorLayer(unicode(layer.source(),'latin1'), unicode(myName,'latin1'), providerName)
if vlayer.isValid():
return vlayer
else:
QMessageBox.warning(None, QCoreApplication.translate("Geoprocessing",vlayer.name()+" is not valid -> exit plugin!"))
#Creates ShapeFileName
#Return: Full Path with Shape Name
def createShapeFileName(self, layer, myPath, process):
if myPath[-1] == "/":
myPath = myPath
else:
myPath = myPath + "/"
i = 1
myTempShape = str(myPath) + process + str(i) + ".shp"
while os.path.isfile(unicode(myTempShape,'latin1')):
i = i + 1
myTempShape = str(myPath) + process + str(i) + ".shp"
return myTempShape
#Creates a QgsVectorFileWriter for shape
#Return: QgsVectorFileWriter
def createShapeFileWriter(self, myTempShape, fields, geometryType):
writer = QgsVectorFileWriter(str(myTempShape), "UTF-8", fields, geometryType, None)
if writer.hasError() != QgsVectorFileWriter.NoError:
message = self.writerErrorMessage(writer.hasError())
QMessageBox.warning(None, QCoreApplication.translate("Geoprocessing","Buffer"), str(message))
return 0
return writer
#Creates a Spatial Index
#Return: QgsSpatialIndex
def createIndex(self, provider):
feat = QgsFeature()
index = QgsSpatialIndex()
while provider.nextFeature(feat):
index.insertFeature(feat)
return index
#Merges single Geometries to one Multi Geometry
#Return: QgsGeometry
def singleToMulti(self, vlayerA):
provider = vlayerA.dataProvider()
feat = QgsFeature()
allAttrs = provider.attributeIndexes()
provider.select(allAttrs)
j = 1
k= 1
geom_array = []
while provider.nextFeature(feat):
geom = feat.geometry()
multi_geom = QgsGeometry()
if geom.type() == 0:
geom_array.append(geom.asPoint())
if geom.isMultipart():
multi_geom = geom.asMultiPoint()
for i in multi_geom:
geom_array.append(i)
else:
geom_array.append(geom.asPoint())
elif geom.type() == 1:
if geom.isMultipart():
multi_geom = geom.asMultiPolyline()
for i in multi_geom:
geom_array.append(i)
else:
geom_array.append(geom.asPolyline())
elif geom.type() == 2:
if geom.isMultipart():
multi_geom = geom.asMultiPolygon()
for i in multi_geom:
geom_array.append(i)
else:
geom_array.append(geom.asPolygon())
else:
QMessageBox.error(None, "Info", QCoreApplication.translate("Geoprocessing","unknown"))
if geom.type() == 0:
return QgsGeometry.fromMultiPoint(geom_array)
elif geom.type() == 1:
return QgsGeometry.fromMultiPolyline(geom_array)
elif geom.type() == 2:
return QgsGeometry.fromMultiPolygon(geom_array)
#Adds a path qualified Shape to canvas
#Return: void
def addShapeToCanvas(self, shapeFilePath):
shapeFilePathList = shapeFilePath.split("/")
layerName = shapeFilePathList[len(shapeFilePathList)-1]
vlayer_new = QgsVectorLayer(shapeFilePath, layerName, "ogr")
if vlayer_new.isValid():
QgsMapLayerRegistry.instance().addMapLayer(vlayer_new)
return 0
else:
# vlayer_new is not valid -> exit plugin!
return 1
#Gets the result geometry Type
#Return: QGis::WKBTYPE
def getResultGeometryType(self, vlayerA, vlayerB):
providerA = vlayerA.dataProvider()
providerB = vlayerB.dataProvider()
featA = QgsFeature()
featB = QgsFeature()
allAttrsA = providerA.attributeIndexes()
allAttrsB = providerB.attributeIndexes()
providerA.select(allAttrsA)
providerB.select(allAttrsB)
providerA.nextFeature(featA)
providerB.nextFeature(featB)
geomA = featA.geometry()
geomB = featB.geometry()
if geomA.type() == QGis.Line:
return providerA.geometryType()
else:
return providerB.geometryType()
#Get the Fieldnames of a Vector Layer
#Return: List of Fieldnames
def getFieldNames(self, vLayer):
provider = vLayer.dataProvider()
myList = self.getFeatureList(vLayer)
fieldList = []
for (k,attr) in myList.iteritems():
fieldList.append(unicode(attr.name(),'latin1'))
return fieldList
#Get the List of Fields
#Return: QGsFieldMap
def getFieldList(self, vlayer):
fProvider = vlayer.dataProvider()
feat = QgsFeature()
allAttrs = fProvider.attributeIndexes()
# start data retrieval: all attributes for each feature
fProvider.select(allAttrs, QgsRectangle(), False)
# retrieve every feature with its attributes
myFields = fProvider.fields()
return myFields
#Get the Features of a vector Layer
#Return: QgsFieldMap
def getFeatureList(self, vlayer):
fProvider = vlayer.dataProvider()
feat = QgsFeature()
allAttrs = fProvider.attributeIndexes()
# start data retrieval: fetch all attributes for each feature
fProvider.select(allAttrs, QgsRectangle(), False)
# retrieve every feature with its attributes
myFields = fProvider.fields()
return myFields
#Merges the Fields of two Vector Layer and adds a_ to the fieldnames of Layer A
#and adds b_ to the fieldnames of Layer B
#Return: Sequence of Fieldnames
def mergeFields(self, vlayerA, vlayerB):
providerB = vlayerB.dataProvider()
myListA = self.getFeatureList(vlayerA)
myListB = self.getFeatureList(vlayerB)
maxAId = 0
for (k,attr) in myListA.iteritems():
if k > maxAId:
maxAId = k
for (k,attr) in myListA.iteritems():
attr.setName("a_"+attr.name())
for (k,attr) in myListB.iteritems():
attr.setName("b_"+attr.name())
for (k,attr) in myListB.iteritems():
maxAId += 1
myListA.update({int(maxAId):attr})
return myListA
#Merges the Attributes of two Vector Layer
#Return: Sequence of Attribute values
def mergeAttributes(self, attA, attB):
myAttribs = {}
maxAId = 0
for (k,attr) in attA.iteritems():
myAttribs.update({int(k):attr})
if k > maxAId:
maxAId = k
for (k,attr) in attB.iteritems():
maxAId += 1
myAttribs.update({int(maxAId):attr})
return myAttribs
# Gets the list of unique attribute values
#Return List of unique Attribute Values
def getUniqueAttributeValues(self,vlayer, fieldID):
myProvider = vlayer.dataProvider()
feat = QgsFeature()
attribList = []
while myProvider.nextFeature(feat):
attrs = feat.attributeMap()
if attribList.count(attrs[fieldID].toString()) == 0:
attribList.append(attrs[fieldID].toString())
return attribList
#Detect the number of all involved objects for later use
#with progressbar
#Return: Number of involved features (int)
def getNumFeatures(self, providerA, providerB):
tmpIndexA = self.createIndex(providerA)
tmpIntersectsA = tmpIndexA.intersects(vlayerB.extent())
tmpIndexB = self.createIndex(providerB)
tmpIntersectsB = tmpIndexB.intersects(vlayerA.extent())
nFeat = len(tmpIntersectsA) + len(tmpIntersectsB)
return nFeat
def makeBuffer(self, provider, mergeBool, bufferDistance):
first = True
feat = QgsFeature()
nFeat = provider.featureCount()
self.geo_ctrl.progressBar.setValue(0)
self.geo_ctrl.progressBar.setRange(0, nFeat)
nElement = 0
featureList=[]
if mergeBool or self.geo_ctrl.cmbAttribA.currentIndex() > 0:
while provider.nextFeature(feat):
buff_geom = feat.geometry().buffer(float(bufferDistance),5)
if first:
unionBuff = buff_geom
first = False
nElement += 1
self.geo_ctrl.progressBar.setValue(nElement)
else:
unionBuff = unionBuff.combine(buff_geom)
nElement += 1
self.geo_ctrl.progressBar.setValue(nElement)
fet = QgsFeature()
fet.setGeometry(unionBuff)
fet.addAttribute(0, QVariant(1))
featureList.append(fet)
else:
while provider.nextFeature(feat):
geom = feat.geometry()
buff_geom = geom.buffer(float(bufferDistance),10)
nElement += 1
self.geo_ctrl.progressBar.setValue(nElement)
fet = QgsFeature()
fet.setGeometry(buff_geom)
fet.addAttribute(0, QVariant(1))
featureList.append(fet)
return featureList
def makeUnion(self, vlayerA, vlayerB):
providerA = vlayerA.dataProvider()
providerB = vlayerB.dataProvider()
featA = QgsFeature()
featB = QgsFeature()
allAttrsA = providerA.attributeIndexes()
allAttrsB = providerB.attributeIndexes()
providerA.select(allAttrsA)
providerB.select(allAttrsB)
index = self.createIndex(providerB)
first = True
unionResult = self.makeIntersection(vlayerA, vlayerB)
diffAResult = self.makeDifference(vlayerA, vlayerB)
diffBResult = self.makeDifference(vlayerB, vlayerA)
# Get and merge all attributes of Layer A
for fet in diffAResult:
attA = fet.attributeMap()
myAttribs = {}
maxId = 0
for (k,attr) in attA.iteritems():
if k > maxId:
maxId = k
myAttribs.update({int(k):attr})
attB = self.getFeatureList(vlayerB)
# Fill up all Layer B Attributes with dummy values
for (k,attr) in attB.iteritems():
maxId += 1
myAttribs.update({int(maxId):QVariant(0)})
fet.setAttributeMap(myAttribs)
unionResult.append(fet)
# Fill up all Layer A Attributes with dummy values
for fet in diffBResult:
attA = self.getFeatureList(vlayerA)
myAttribs = {}
maxId = 0
for (k,attr) in attA.iteritems():
if k > maxId:
maxId = k
myAttribs.update({int(k):QVariant(0)})
# Get and merge all Layer B Attribute values
attB = fet.attributeMap()
for (k,attr) in attB.iteritems():
maxId += 1
myAttribs.update({int(maxId):attr})
fet.setAttributeMap(myAttribs)
unionResult.append(fet)
return unionResult
def makeDifference(self, vlayerA, vlayerB):
providerA = vlayerA.dataProvider()
providerB = vlayerB.dataProvider()
featA = QgsFeature()
featB = QgsFeature()
allAttrsA = providerA.attributeIndexes()
allAttrsB = providerB.attributeIndexes()
#select only to the intersection square of the bounding boxes of Layer A
providerA.select(allAttrsA)
providerB.select(allAttrsB, vlayerA.extent())
index = self.createIndex(providerB)
resultList = []
self.message = False
while providerA.nextFeature(featA):
geomA = featA.geometry()
attribA = featA.attributeMap()
intersects = index.intersects(geomA.boundingBox())
for id in intersects:
vlayerB.featureAtId(int(id), featB)
attribB = featB.attributeMap()
try:
geomA = geomA.difference(featB.geometry())
except:
if self.message==False:
QMessageBox.warning(None, QCoreApplication.translate("Geoprocessing","Error"), self.topoErrorMessage)
self.message = True
fet = QgsFeature()
fet.setGeometry(geomA)
fet.setAttributeMap(attribA)
if self.isValidGeometry(fet):
resultList.append(fet)
else:
break
return resultList
def makeSymDifference(self, writer, vlayerA, vlayerB):
providerA = vlayerA.dataProvider()
providerB = vlayerB.dataProvider()
featA = QgsFeature()
featB = QgsFeature()
allAttrsA = providerA.attributeIndexes()
allAttrsB = providerB.attributeIndexes()
#select only to the intersection square of the bounding boxes of Layer A
providerA.select(allAttrsA)
providerB.select(allAttrsB)
# index = self.createIndex(providerB)
while providerA.nextFeature(featA):
geomA = featA.geometry()
attribA = featA.attributeMap()
# intersects = index.intersects(geomA.boundingBox())
while providerB.nextFeature(featB):
geomA = geomA.symDifference(featB.geometry())
fet = QgsFeature()
fet.setGeometry(geomA)
fet.setAttributeMap(attribA)
if self.isValidGeometry(fet):
writer.addFeature(fet)
else:
break
return 0
def makeIntersection(self, vlayerA, vlayerB):
providerA = vlayerA.dataProvider()
providerB = vlayerB.dataProvider()
featA = QgsFeature()
featB = QgsFeature()
allAttrsA = providerA.attributeIndexes()
allAttrsB = providerB.attributeIndexes()
#select only to the intersection square of the bounding boxes
combinedExtent = vlayerB.extent().intersect(vlayerA.extent())
providerA.select(allAttrsA, combinedExtent)
providerB.select(allAttrsB, combinedExtent)
index = self.createIndex(providerB)
nElement = 0
resultList = []
self.geo_ctrl.progressBar.setValue(0)
self.geo_ctrl.progressBar.setRange(0, -1)
while providerA.nextFeature(featA):
geomA = featA.geometry()
attribA = featA.attributeMap()
intersects = index.intersects(geomA.boundingBox())
nElement += len(intersects)
nElement += 1
# self.geo_ctrl.progressBar.setValue(-1)
self.geo_ctrl.progressBar.setValue(nElement)
for id in intersects:
vlayerB.featureAtId(int(id), featB)
attribB = featB.attributeMap()
result = geomA.intersection(featB.geometry())
mAttributes = self.mergeAttributes(attribA, attribB)
fet = QgsFeature()
fet.setGeometry(result)
fet.setAttributeMap(mAttributes)
if self.isValidGeometry(fet):
resultList.append(fet)
else:
break
return resultList
def makeDissolve(self, vlayerA, fieldID=-1, attribValue=""):
providerA = vlayerA.dataProvider()
featA = QgsFeature()
allAttrsA = providerA.attributeIndexes()
providerA.select(allAttrsA)
result = QgsFeature()
first = True
nElement = 0
resultList = []
while providerA.nextFeature(featA):
attrs = featA.attributeMap()
if fieldID==-1:
if first:
result.setGeometry(featA.geometry())
first = False
else:
result.setGeometry(result.geometry().combine(featA.geometry()))
self.nElement += 1
self.geo_ctrl.progressBar.setValue(self.nElement)
else:
if attrs[fieldID].toString() == unicode(attribValue,'latin1'):
if first:
result.setGeometry(featA.geometry())
first = False
else:
result.setGeometry(result.geometry().combine(featA.geometry()))
self.nElement += 1
self.geo_ctrl.progressBar.setValue(self.nElement)
result.addAttribute(fieldID, QVariant(attribValue))
if self.isValidGeometry(result):
resultList.append(result)
return resultList
def makeMerge(self, vlayerA, vlayerB):
providerA = vlayerA.dataProvider()
featA = QgsFeature()
allAttrsA = providerA.attributeIndexes()
providerA.select(allAttrsA)
resultList = []
self.geo_ctrl.progressBar.setValue(0)
self.geo_ctrl.progressBar.setRange(0, -1)
while providerA.nextFeature(featA):
resultList.append(featA)
providerB = vlayerB.dataProvider()
featB = QgsFeature()
allAttrsB = providerB.attributeIndexes()
providerB.select(allAttrsB)
while providerB.getNextFeature(featB):
resultList.append(featB)
for fet in resultList:
print fet.geometry().exportToWkt()
return resultList
