sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-04-25 00:03:06 -04:00
Code Issues Packages Projects Releases Wiki Activity

first take on porting ftools to vector iterator api

Browse Source
This commit is contained in:
Juergen E. Fischer 2013-02-01 01:03:19 +01:00
parent 0d1f3d288d
commit 2f23b1e83b
19 changed files with 365 additions and 456 deletions

1
debian/control.raring vendored

@ -31,6 +31,7 @@ Build-Depends:
python-qt4-dev (>=4.1.0), python-qt4-dev (>=4.1.0),
python-sip (>= 4.5.0), python-sip (>= 4.5.0),
python-sip-dev (>= 4.5.0), python-sip-dev (>= 4.5.0),
libpython2.7-dev,
libosgearth-dev, libosgearth-dev,
libopenscenegraph-dev, libopenscenegraph-dev,
git, git,

4
python/plugins/fTools/tools/doEliminate.py

@ -160,7 +160,7 @@ class Dialog(QtGui.QDialog, Ui_Dialog):
for fid2Eliminate in inLayer.selectedFeaturesIds(): for fid2Eliminate in inLayer.selectedFeaturesIds():
feat = QgsFeature() feat = QgsFeature()
if inLayer.featureAtId(fid2Eliminate, feat, True, False): if inLayer.getFeatures( QgsFeatureRequest().setFilterFid( fid2Eliminate ).setSubsetOfAttributes([]) ).nextFeature( feat ):
geom2Eliminate = feat.geometry() geom2Eliminate = feat.geometry()
bbox = geom2Eliminate.boundingBox() bbox = geom2Eliminate.boundingBox()
outLayer.select(bbox, False) # make a new selection outLayer.select(bbox, False) # make a new selection
@ -171,7 +171,7 @@ class Dialog(QtGui.QDialog, Ui_Dialog):
for selFid in outLayer.selectedFeaturesIds(): for selFid in outLayer.selectedFeaturesIds():
selFeat = QgsFeature() selFeat = QgsFeature()
if outLayer.featureAtId(selFid, selFeat, True, False): if outLayer.getFeatures( QgsFeatureRequest().setFilterFid( selFid ).setSubsetOfAttributes([]) ).nextFeature( selFeat ):
selGeom = selFeat.geometry() selGeom = selFeat.geometry()
if geom2Eliminate.intersects(selGeom): # we have a candidate if geom2Eliminate.intersects(selGeom): # we have a candidate

194
python/plugins/fTools/tools/doGeometry.py

@ -353,12 +353,9 @@ class geometryThread( QThread ):
def single_to_multi( self ): def single_to_multi( self ):
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
fields = vprovider.fields()
allValid = True allValid = True
geomType = self.singleToMultiGeom( vprovider.geometryType() ) geomType = self.singleToMultiGeom( vprovider.geometryType() )
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, vprovider.fields(),
geomType, vprovider.crs() ) geomType, vprovider.crs() )
inFeat = QgsFeature() inFeat = QgsFeature()
outFeat = QgsFeature() outFeat = QgsFeature()
@ -376,12 +373,11 @@ class geometryThread( QThread ):
merge_all = self.myField == QString( "--- " + self.tr( "Merge all" ) + " ---" ) merge_all = self.myField == QString( "--- " + self.tr( "Merge all" ) + " ---" )
if not len( unique ) == self.vlayer.featureCount() or merge_all: if not len( unique ) == self.vlayer.featureCount() or merge_all:
for i in unique: for i in unique:
vprovider.rewind()
multi_feature= [] multi_feature= []
first = True first = True
vprovider.select( allAttrs ) fit = vprovider.getFeatures()
while vprovider.nextFeature( inFeat ): while fit.nextFeature( inFeat ):
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
if not merge_all: if not merge_all:
idVar = atMap[ index ] idVar = atMap[ index ]
else: else:
@ -396,7 +392,7 @@ class geometryThread( QThread ):
multi_feature.extend( feature_list ) multi_feature.extend( feature_list )
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
outFeat.setAttributeMap( atts ) outFeat.setAttributes( atts )
outGeom = QgsGeometry( self.convertGeometry( multi_feature, vType ) ) outGeom = QgsGeometry( self.convertGeometry( multi_feature, vType ) )
if not outGeom.isGeosValid(): if not outGeom.isGeosValid():
allValid = "valid_error" allValid = "valid_error"
@ -409,11 +405,8 @@ class geometryThread( QThread ):
def multi_to_single( self ): def multi_to_single( self ):
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
fields = vprovider.fields()
geomType = self.multiToSingleGeom( vprovider.geometryType() ) geomType = self.multiToSingleGeom( vprovider.geometryType() )
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, vprovider.fields(),
geomType, vprovider.crs() ) geomType, vprovider.crs() )
inFeat = QgsFeature() inFeat = QgsFeature()
outFeat = QgsFeature() outFeat = QgsFeature()
@ -423,13 +416,14 @@ class geometryThread( QThread ):
nElement = 0 nElement = 0
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 )
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) )
while vprovider.nextFeature( inFeat ): fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
featList = self.extractAsSingle( inGeom ) featList = self.extractAsSingle( inGeom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
for i in featList: for i in featList:
outFeat.setGeometry( i ) outFeat.setGeometry( i )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
@ -438,10 +432,7 @@ class geometryThread( QThread ):
def extract_nodes( self ): def extract_nodes( self ):
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes() writer = QgsVectorFileWriter( self.myName, self.myEncoding, vprovider.fields(),
vprovider.select( allAttrs )
fields = vprovider.fields()
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBPoint, vprovider.crs() ) QGis.WKBPoint, vprovider.crs() )
inFeat = QgsFeature() inFeat = QgsFeature()
outFeat = QgsFeature() outFeat = QgsFeature()
@ -451,13 +442,14 @@ class geometryThread( QThread ):
nElement = 0 nElement = 0
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 )
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) )
while vprovider.nextFeature( inFeat ): fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
pointList = ftools_utils.extractPoints( inGeom ) pointList = ftools_utils.extractPoints( inGeom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
for i in pointList: for i in pointList:
outFeat.setGeometry( outGeom.fromPoint( i ) ) outFeat.setGeometry( outGeom.fromPoint( i ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
@ -466,10 +458,7 @@ class geometryThread( QThread ):
def polygons_to_lines( self ): def polygons_to_lines( self ):
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes() writer = QgsVectorFileWriter( self.myName, self.myEncoding, vproviders.fields(),
vprovider.select( allAttrs )
fields = vprovider.fields()
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBLineString, vprovider.crs() ) QGis.WKBLineString, vprovider.crs() )
inFeat = QgsFeature() inFeat = QgsFeature()
outFeat = QgsFeature() outFeat = QgsFeature()
@ -479,16 +468,18 @@ class geometryThread( QThread ):
nElement = 0 nElement = 0
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0)
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) )
while vprovider.nextFeature( inFeat ):
fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
multi = False multi = False
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
if inGeom.isMultipart(): if inGeom.isMultipart():
multi = True multi = True
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
lineList = self.extractAsLine( inGeom ) lineList = self.extractAsLine( inGeom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
for h in lineList: for h in lineList:
outFeat.setGeometry( outGeom.fromPolyline( h ) ) outFeat.setGeometry( outGeom.fromPolyline( h ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
@ -497,10 +488,7 @@ class geometryThread( QThread ):
def lines_to_polygons( self ): def lines_to_polygons( self ):
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes() writer = QgsVectorFileWriter( self.myName, self.myEncoding, vproviders.fields(),
vprovider.select( allAttrs )
fields = vprovider.fields()
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBPolygon, vprovider.crs() ) QGis.WKBPolygon, vprovider.crs() )
inFeat = QgsFeature() inFeat = QgsFeature()
outFeat = QgsFeature() outFeat = QgsFeature()
@ -509,7 +497,9 @@ class geometryThread( QThread ):
nElement = 0 nElement = 0
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0)
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) )
while vprovider.nextFeature( inFeat ):
fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
outGeomList = [] outGeomList = []
multi = False multi = False
nElement += 1 nElement += 1
@ -522,8 +512,8 @@ class geometryThread( QThread ):
polyGeom = self.remove_bad_lines( outGeomList ) polyGeom = self.remove_bad_lines( outGeomList )
if len( polyGeom ) <> 0: if len( polyGeom ) <> 0:
outFeat.setGeometry( QgsGeometry.fromPolygon( polyGeom ) ) outFeat.setGeometry( QgsGeometry.fromPolygon( polyGeom ) )
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
del writer del writer
return True return True
@ -552,7 +542,6 @@ class geometryThread( QThread ):
nElement = 0 nElement = 0
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0)
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, vprovider.featureCount() ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, vprovider.featureCount() ) )
@ -560,8 +549,8 @@ class geometryThread( QThread ):
( fields, index1, index2 ) = self.checkGeometryFields( self.vlayer ) ( fields, index1, index2 ) = self.checkGeometryFields( self.vlayer )
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
vprovider.geometryType(), vprovider.crs() ) vprovider.geometryType(), vprovider.crs() )
vprovider.select( allAttrs ) fit = vprovider.getFeatures()
while vprovider.nextFeature(inFeat): while fit.nextFeature(inFeat):
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
nElement += 1 nElement += 1
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
@ -572,8 +561,8 @@ class geometryThread( QThread ):
( attr1, attr2 ) = self.simpleMeasure( inGeom, self.myCalcType, ellips, crs ) ( attr1, attr2 ) = self.simpleMeasure( inGeom, self.myCalcType, ellips, crs )
outFeat.setGeometry( inGeom ) outFeat.setGeometry( inGeom )
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
outFeat.addAttribute( index1, QVariant( attr1 ) ) outFeat.addAttribute( index1, QVariant( attr1 ) )
outFeat.addAttribute( index2, QVariant( attr2 ) ) outFeat.addAttribute( index2, QVariant( attr2 ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
@ -582,8 +571,8 @@ class geometryThread( QThread ):
else: # update existing file else: # update existing file
( index1, index2 ) = self.findOrCreateFields( self.vlayer ) ( index1, index2 ) = self.findOrCreateFields( self.vlayer )
vprovider.select( allAttrs ) fit = vprovider.getFeatures()
while vprovider.nextFeature(inFeat): while fit.nextFeature(inFeat):
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
nElement += 1 nElement += 1
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
@ -601,10 +590,7 @@ class geometryThread( QThread ):
def polygon_centroids( self ): def polygon_centroids( self ):
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes() writer = QgsVectorFileWriter( self.myName, self.myEncoding, vprovider.fields(),
vprovider.select( allAttrs )
fields = vprovider.fields()
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBPoint, vprovider.crs() ) QGis.WKBPoint, vprovider.crs() )
inFeat = QgsFeature() inFeat = QgsFeature()
outFeat = QgsFeature() outFeat = QgsFeature()
@ -612,15 +598,16 @@ class geometryThread( QThread ):
nElement = 0 nElement = 0
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 )
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) )
while vprovider.nextFeature( inFeat ): fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
outGeom = inGeom.centroid() outGeom = inGeom.centroid()
if outGeom is None: if outGeom is None:
return "math_error" return "math_error"
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
outFeat.setGeometry( QgsGeometry( outGeom ) ) outFeat.setGeometry( QgsGeometry( outGeom ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
del writer del writer
@ -630,11 +617,9 @@ class geometryThread( QThread ):
import voronoi import voronoi
from sets import Set from sets import Set
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes() fields = [ QgsField( "POINTA", QVariant.Double ),
vprovider.select( allAttrs ) QgsField( "POINTB", QVariant.Double ),
fields = { 0 : QgsField( "POINTA", QVariant.Double ), QgsField( "POINTC", QVariant.Double ) ]
1 : QgsField( "POINTB", QVariant.Double ),
2 : QgsField( "POINTC", QVariant.Double ) }
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBPolygon, vprovider.crs() ) QGis.WKBPolygon, vprovider.crs() )
inFeat = QgsFeature() inFeat = QgsFeature()
@ -642,7 +627,8 @@ class geometryThread( QThread ):
pts = [] pts = []
ptDict = {} ptDict = {}
ptNdx = -1 ptNdx = -1
while vprovider.nextFeature( inFeat ): fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
geom = QgsGeometry( inFeat.geometry() ) geom = QgsGeometry( inFeat.geometry() )
point = geom.asPoint() point = geom.asPoint()
x = point.x() x = point.x()
@ -669,7 +655,7 @@ class geometryThread( QThread ):
polygon = [] polygon = []
step = 0 step = 0
for index in indicies: for index in indicies:
vprovider.featureAtId( ptDict[ ids[ index ] ], inFeat, True, allAttrs ) vprovider.getFeatures( QgsFeatureRequest().setFilterFid( ptDict[ ids[ index ] ] ) ).nextFeature( inFeat )
geom = QgsGeometry( inFeat.geometry() ) geom = QgsGeometry( inFeat.geometry() )
point = QgsPoint( geom.asPoint() ) point = QgsPoint( geom.asPoint() )
polygon.append( point ) polygon.append( point )
@ -685,8 +671,6 @@ class geometryThread( QThread ):
def voronoi_polygons( self ): def voronoi_polygons( self ):
vprovider = self.vlayer.dataProvider() vprovider = self.vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
writer = QgsVectorFileWriter( self.myName, self.myEncoding, vprovider.fields(), writer = QgsVectorFileWriter( self.myName, self.myEncoding, vprovider.fields(),
QGis.WKBPolygon, vprovider.crs() ) QGis.WKBPolygon, vprovider.crs() )
inFeat = QgsFeature() inFeat = QgsFeature()
@ -700,7 +684,8 @@ class geometryThread( QThread ):
pts = [] pts = []
ptDict = {} ptDict = {}
ptNdx = -1 ptNdx = -1
while vprovider.nextFeature( inFeat ): fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
geom = QgsGeometry( inFeat.geometry() ) geom = QgsGeometry( inFeat.geometry() )
point = geom.asPoint() point = geom.asPoint()
x = point.x() - extent.xMinimum() x = point.x() - extent.xMinimum()
@ -721,12 +706,12 @@ class geometryThread( QThread ):
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 )
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) )
for site, edges in c.polygons.iteritems(): for site, edges in c.polygons.iteritems():
vprovider.featureAtId( ptDict[ ids[ site ] ], inFeat, True, allAttrs ) vprovider.getFeatures( QgsFeatureRequest().setFilterFid( ptDict[ ids[ site ] ] ) ).nextFeature( inFeat )
lines = self.clip_voronoi( edges, c, width, height, extent, extraX, extraY ) lines = self.clip_voronoi( edges, c, width, height, extent, extraX, extraY )
geom = QgsGeometry.fromMultiPoint( lines ) geom = QgsGeometry.fromMultiPoint( lines )
geom = QgsGeometry( geom.convexHull() ) geom = QgsGeometry( geom.convexHull() )
outFeat.setGeometry( geom ) outFeat.setGeometry( geom )
outFeat.setAttributeMap( inFeat.attributeMap() ) outFeat.setAttributes( inFeat.attributes() )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
@ -829,16 +814,16 @@ class geometryThread( QThread ):
def layer_extent( self ): def layer_extent( self ):
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 )
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, 0 ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, 0 ) )
fields = { 0 : QgsField( "MINX", QVariant.Double ), fields = [ QgsField( "MINX", QVariant.Double ),
1 : QgsField( "MINY", QVariant.Double ), QgsField( "MINY", QVariant.Double ),
2 : QgsField( "MAXX", QVariant.Double ), QgsField( "MAXX", QVariant.Double ),
3 : QgsField( "MAXY", QVariant.Double ), QgsField( "MAXY", QVariant.Double ),
4 : QgsField( "CNTX", QVariant.Double ), QgsField( "CNTX", QVariant.Double ),
5 : QgsField( "CNTY", QVariant.Double ), QgsField( "CNTY", QVariant.Double ),
6 : QgsField( "AREA", QVariant.Double ), QgsField( "AREA", QVariant.Double ),
7 : QgsField( "PERIM", QVariant.Double ), QgsField( "PERIM", QVariant.Double ),
8 : QgsField( "HEIGHT", QVariant.Double ), QgsField( "HEIGHT", QVariant.Double ),
9 : QgsField( "WIDTH", QVariant.Double ) } QgsField( "WIDTH", QVariant.Double ) ]
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBPolygon, self.vlayer.crs() ) QGis.WKBPolygon, self.vlayer.crs() )
@ -861,16 +846,16 @@ class geometryThread( QThread ):
geometry = QgsGeometry().fromPolygon( [ rect ] ) geometry = QgsGeometry().fromPolygon( [ rect ] )
feat = QgsFeature() feat = QgsFeature()
feat.setGeometry( geometry ) feat.setGeometry( geometry )
feat.setAttributeMap( { 0 : QVariant( minx ), feat.setAttributes( [ QVariant( minx ),
1 : QVariant( miny ), QVariant( miny ),
2 : QVariant( maxx ), QVariant( maxx ),
3 : QVariant( maxy ), QVariant( maxy ),
4 : QVariant( cntx ), QVariant( cntx ),
5 : QVariant( cnty ), QVariant( cnty ),
6 : QVariant( area ), QVariant( area ),
7 : QVariant( perim ), QVariant( perim ),
8 : QVariant( height ), QVariant( height ),
9 : QVariant( width ) } ) QVariant( width ) ] )
writer.addFeature( feat ) writer.addFeature( feat )
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, 100 ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, 100 ) )
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 )
@ -926,20 +911,21 @@ class geometryThread( QThread ):
geometry = QgsGeometry().fromPolygon( [ rect ] ) geometry = QgsGeometry().fromPolygon( [ rect ] )
outFeat.setGeometry( geometry ) outFeat.setGeometry( geometry )
outFeat.setAttributeMap( { 0 : QVariant( minx ), outFeat.setAttributes( [ QVariant( minx ),
1 : QVariant( miny ), QVariant( miny ),
2 : QVariant( maxx ), QVariant( maxx ),
3 : QVariant( maxy ), QVariant( maxy ),
4 : QVariant( cntx ), QVariant( cntx ),
5 : QVariant( cnty ), QVariant( cnty ),
6 : QVariant( area ), QVariant( area ),
7 : QVariant( perim ), QVariant( perim ),
8 : QVariant( height ), QVariant( height ),
9 : QVariant( width ) } ) QVariant( width ) ] )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
else: else:
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, vprovider.featureCount() ) ) self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, vprovider.featureCount() ) )
while vprovider.nextFeature( inFeat ): fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement ) self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
nElement += 1 nElement += 1
@ -962,16 +948,16 @@ class geometryThread( QThread ):
geometry = QgsGeometry().fromPolygon( [ rect ] ) geometry = QgsGeometry().fromPolygon( [ rect ] )
outFeat.setGeometry( geometry ) outFeat.setGeometry( geometry )
outFeat.setAttributeMap( { 0 : QVariant( minx ), outFeat.setAttributes( [ QVariant( minx ),
1 : QVariant( miny ), QVariant( miny ),
2 : QVariant( maxx ), QVariant( maxx ),
3 : QVariant( maxy ), QVariant( maxy ),
4 : QVariant( cntx ), QVariant( cntx ),
5 : QVariant( cnty ), QVariant( cnty ),
6 : QVariant( area ), QVariant( area ),
7 : QVariant( perim ), QVariant( perim ),
8 : QVariant( height ), QVariant( height ),
9 : QVariant( width ) } ) QVariant( width ) ] )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
del writer del writer

274
python/plugins/fTools/tools/doGeoprocessing.py

@ -323,11 +323,8 @@ class geoprocessingThread( QThread ):
GEOS_EXCEPT = True GEOS_EXCEPT = True
FEATURE_EXCEPT = True FEATURE_EXCEPT = True
vproviderA = self.vlayerA.dataProvider() vproviderA = self.vlayerA.dataProvider()
allAttrs = vproviderA.attributeIndexes()
vproviderA.select( allAttrs )
fields = vproviderA.fields()
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, vproviderA.fields(),
QGis.WKBPolygon, vproviderA.crs() ) QGis.WKBPolygon, vproviderA.crs() )
# check if writer was created properly, if not, return with error # check if writer was created properly, if not, return with error
if writer.hasError(): if writer.hasError():
@ -349,7 +346,7 @@ class geoprocessingThread( QThread ):
if self.myMerge: if self.myMerge:
first = True first = True
for inFeat in selectionA: for inFeat in selectionA:
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
if useField: if useField:
value = atMap[ self.myParam ].doDouble()[ 0 ] value = atMap[ self.myParam ].doDouble()[ 0 ]
else: else:
@ -379,7 +376,7 @@ class geoprocessingThread( QThread ):
# without dissolve # without dissolve
else: else:
for inFeat in selectionA: for inFeat in selectionA:
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
if useField: if useField:
value = atMap[ self.myParam ].toDouble()[ 0 ] value = atMap[ self.myParam ].toDouble()[ 0 ]
else: else:
@ -389,7 +386,7 @@ class geoprocessingThread( QThread ):
outGeom = inGeom.buffer( float( value ), self.mySegments ) outGeom = inGeom.buffer( float( value ), self.mySegments )
try: try:
outFeat.setGeometry( outGeom ) outFeat.setGeometry( outGeom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -407,8 +404,9 @@ class geoprocessingThread( QThread ):
# with dissolve # with dissolve
if self.myMerge: if self.myMerge:
first = True first = True
while vproviderA.nextFeature( inFeat ): fit = vproviderA.getFeatures()
atMap = inFeat.attributeMap() while fit.nextFeature( inFeat ):
atMap = inFeat.attributes()
if useField: if useField:
value = atMap[ self.myParam ].toDouble()[ 0 ] value = atMap[ self.myParam ].toDouble()[ 0 ]
else: else:
@ -437,8 +435,9 @@ class geoprocessingThread( QThread ):
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
# without dissolve # without dissolve
else: else:
while vproviderA.nextFeature( inFeat ): fit = vproviderA.getFeatures()
atMap = inFeat.attributeMap() while fit.nextFeature( inFeat ):
atMap = inFeat.attributes()
if useField: if useField:
value = atMap[ self.myParam ].toDouble()[ 0 ] value = atMap[ self.myParam ].toDouble()[ 0 ]
else: else:
@ -448,7 +447,7 @@ class geoprocessingThread( QThread ):
outGeom = inGeom.buffer( float( value ), self.mySegments ) outGeom = inGeom.buffer( float( value ), self.mySegments )
try: try:
outFeat.setGeometry( outGeom ) outFeat.setGeometry( outGeom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -465,10 +464,7 @@ class geoprocessingThread( QThread ):
GEOS_EXCEPT = True GEOS_EXCEPT = True
FEATURE_EXCEPT = True FEATURE_EXCEPT = True
vproviderA = self.vlayerA.dataProvider() vproviderA = self.vlayerA.dataProvider()
allAttrsA = vproviderA.attributeIndexes() writer = QgsVectorFileWriter( self.myName, self.myEncoding, vprovider.fields(),
vproviderA.select(allAttrsA)
fields = vproviderA.fields()
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBPolygon, vproviderA.crs() ) QGis.WKBPolygon, vproviderA.crs() )
if writer.hasError(): if writer.hasError():
return GEOS_EXCEPT, FEATURE_EXCEPT, True, writer.errorMessage() return GEOS_EXCEPT, FEATURE_EXCEPT, True, writer.errorMessage()
@ -494,7 +490,7 @@ class geoprocessingThread( QThread ):
outID = 0 outID = 0
vproviderA.rewind() vproviderA.rewind()
for inFeat in selectionA: for inFeat in selectionA:
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
idVar = atMap[ self.myParam ] idVar = atMap[ self.myParam ]
if idVar.toString().trimmed() == i.toString().trimmed(): if idVar.toString().trimmed() == i.toString().trimmed():
if first: if first:
@ -547,9 +543,10 @@ class geoprocessingThread( QThread ):
hull = [] hull = []
first = True first = True
outID = 0 outID = 0
vproviderA.rewind()
while vproviderA.nextFeature( inFeat ): fitA = vproviderA.getFeatures()
atMap = inFeat.attributeMap() while fitA.nextFeature( inFeat ):
atMap = inFeat.attributes()
idVar = atMap[ self.myParam ] idVar = atMap[ self.myParam ]
if idVar.toString().trimmed() == i.toString().trimmed(): if idVar.toString().trimmed() == i.toString().trimmed():
if first: if first:
@ -577,7 +574,8 @@ class geoprocessingThread( QThread ):
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
hull = [] hull = []
while vproviderA.nextFeature( inFeat ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeat ):
inGeom = QgsGeometry( inFeat.geometry() ) inGeom = QgsGeometry( inFeat.geometry() )
points = ftools_utils.extractPoints( inGeom ) points = ftools_utils.extractPoints( inGeom )
hull.extend( points ) hull.extend( points )
@ -597,10 +595,8 @@ class geoprocessingThread( QThread ):
GEOS_EXCEPT = True GEOS_EXCEPT = True
FEATURE_EXCEPT = True FEATURE_EXCEPT = True
vproviderA = self.vlayerA.dataProvider() vproviderA = self.vlayerA.dataProvider()
allAttrsA = vproviderA.attributeIndexes()
fields = vproviderA.fields()
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, vproviderA.fields(),
vproviderA.geometryType(), vproviderA.crs() ) vproviderA.geometryType(), vproviderA.crs() )
if writer.hasError(): if writer.hasError():
return GEOS_EXCEPT, FEATURE_EXCEPT, True, writer.errorMessage() return GEOS_EXCEPT, FEATURE_EXCEPT, True, writer.errorMessage()
@ -610,9 +606,6 @@ class geoprocessingThread( QThread ):
nElement = 0 nElement = 0
attrs = None attrs = None
vproviderA.rewind()
vproviderA.select( allAttrsA )
# there is selection in input layer # there is selection in input layer
if self.mySelectionA: if self.mySelectionA:
nFeat = self.vlayerA.selectedFeatureCount() nFeat = self.vlayerA.selectedFeatureCount()
@ -625,7 +618,7 @@ class geoprocessingThread( QThread ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
if first: if first:
attrs = inFeat.attributeMap() attrs = inFeat.attributes()
tmpInGeom = QgsGeometry( inFeat.geometry() ) tmpInGeom = QgsGeometry( inFeat.geometry() )
outFeat.setGeometry( tmpInGeom ) outFeat.setGeometry( tmpInGeom )
first = False first = False
@ -638,7 +631,7 @@ class geoprocessingThread( QThread ):
except: except:
GEOS_EXCEPT = False GEOS_EXCEPT = False
continue continue
outFeat.setAttributeMap( attrs ) outFeat.setAttributes( attrs )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
else: else:
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0)
@ -650,7 +643,7 @@ class geoprocessingThread( QThread ):
for inFeat in selectionA: for inFeat in selectionA:
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
tempItem = unicode(atMap[self.myParam].toString().trimmed()) tempItem = unicode(atMap[self.myParam].toString().trimmed())
if not (tempItem in outFeats): if not (tempItem in outFeats):
@ -664,7 +657,7 @@ class geoprocessingThread( QThread ):
continue continue
for k in outFeats.keys(): for k in outFeats.keys():
feature = QgsFeature() feature = QgsFeature()
feature.setAttributeMap(attrs[k]) feature.setAttributes(attrs[k])
feature.setGeometry(outFeats[k]) feature.setGeometry(outFeats[k])
writer.addFeature( feature ) writer.addFeature( feature )
# there is no selection in input layer # there is no selection in input layer
@ -674,11 +667,12 @@ class geoprocessingThread( QThread ):
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0)
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
first = True first = True
while vproviderA.nextFeature( inFeat ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeat ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
if first: if first:
attrs = inFeat.attributeMap() attrs = inFeat.attributes()
tmpInGeom = QgsGeometry( inFeat.geometry() ) tmpInGeom = QgsGeometry( inFeat.geometry() )
outFeat.setGeometry( tmpInGeom ) outFeat.setGeometry( tmpInGeom )
first = False first = False
@ -691,7 +685,7 @@ class geoprocessingThread( QThread ):
except: except:
GEOS_EXCEPT = False GEOS_EXCEPT = False
continue continue
outFeat.setAttributeMap( attrs ) outFeat.setAttributes( attrs )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
else: else:
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0)
@ -700,10 +694,11 @@ class geoprocessingThread( QThread ):
outFeats = {} outFeats = {}
attrs = {} attrs = {}
while vproviderA.nextFeature( inFeat ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeat ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
tempItem = unicode(atMap[self.myParam].toString().trimmed()) tempItem = unicode(atMap[self.myParam].toString().trimmed())
if not (tempItem in outFeats): if not (tempItem in outFeats):
@ -717,7 +712,7 @@ class geoprocessingThread( QThread ):
continue continue
for k in outFeats.keys(): for k in outFeats.keys():
feature = QgsFeature() feature = QgsFeature()
feature.setAttributeMap(attrs[k]) feature.setAttributes(attrs[k])
feature.setGeometry(outFeats[k]) feature.setGeometry(outFeats[k])
writer.addFeature( feature ) writer.addFeature( feature )
del writer del writer
@ -727,12 +722,7 @@ class geoprocessingThread( QThread ):
GEOS_EXCEPT = True GEOS_EXCEPT = True
FEATURE_EXCEPT = True FEATURE_EXCEPT = True
vproviderA = self.vlayerA.dataProvider() vproviderA = self.vlayerA.dataProvider()
allAttrsA = vproviderA.attributeIndexes()
vproviderA.select( allAttrsA )
vproviderB = self.vlayerB.dataProvider() vproviderB = self.vlayerB.dataProvider()
allAttrsB = vproviderB.attributeIndexes()
vproviderB.select( allAttrsB )
fields = vproviderA.fields()
# check for crs compatibility # check for crs compatibility
crsA = vproviderA.crs() crsA = vproviderA.crs()
@ -742,7 +732,7 @@ class geoprocessingThread( QThread ):
else: else:
crs_match = crsA == crsB crs_match = crsA == crsB
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, vproviderA.fields(),
vproviderA.geometryType(), vproviderA.crs() ) vproviderA.geometryType(), vproviderA.crs() )
if writer.hasError(): if writer.hasError():
return GEOS_EXCEPT, FEATURE_EXCEPT, crs_match, writer.errorMessage() return GEOS_EXCEPT, FEATURE_EXCEPT, crs_match, writer.errorMessage()
@ -753,8 +743,6 @@ class geoprocessingThread( QThread ):
nElement = 0 nElement = 0
index = ftools_utils.createIndex( vproviderB ) index = ftools_utils.createIndex( vproviderB )
vproviderB.rewind()
vproviderB.select( allAttrsB )
# there is selection in input layer # there is selection in input layer
if self.mySelectionA: if self.mySelectionA:
@ -771,12 +759,12 @@ class geoprocessingThread( QThread ):
add = True add = True
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
diff_geom = QgsGeometry( geom ) diff_geom = QgsGeometry( geom )
atMap = inFeatA.attributeMap() atMap = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
# is intersect feature in selection # is intersect feature in selection
if id in selectionB: if id in selectionB:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if diff_geom.intersects( tmpGeom ): if diff_geom.intersects( tmpGeom ):
@ -788,7 +776,7 @@ class geoprocessingThread( QThread ):
if add: if add:
try: try:
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -801,10 +789,10 @@ class geoprocessingThread( QThread ):
add = True add = True
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
diff_geom = QgsGeometry( geom ) diff_geom = QgsGeometry( geom )
atMap = inFeatA.attributeMap() atMap = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if diff_geom.intersects( tmpGeom ): if diff_geom.intersects( tmpGeom ):
@ -816,7 +804,7 @@ class geoprocessingThread( QThread ):
if add: if add:
try: try:
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -826,23 +814,22 @@ class geoprocessingThread( QThread ):
nFeat = vproviderA.featureCount() nFeat = vproviderA.featureCount()
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
vproviderA.rewind()
vproviderA.select( allAttrsA )
# we have selection in overlay layer # we have selection in overlay layer
if self.mySelectionB: if self.mySelectionB:
selectionB = self.vlayerB.selectedFeaturesIds() selectionB = self.vlayerB.selectedFeaturesIds()
while vproviderA.nextFeature( inFeatA ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeatA ):
nElement += 1 nElement += 1
add = True add = True
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
diff_geom = QgsGeometry( geom ) diff_geom = QgsGeometry( geom )
atMap = inFeatA.attributeMap() atMap = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
# now check if id in selection # now check if id in selection
if id in selectionB: if id in selectionB:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if diff_geom.intersects( tmpGeom ): if diff_geom.intersects( tmpGeom ):
@ -854,23 +841,24 @@ class geoprocessingThread( QThread ):
if add: if add:
try: try:
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
continue continue
# we have no selection in overlay layer # we have no selection in overlay layer
else: else:
while vproviderA.nextFeature( inFeatA ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeatA ):
nElement += 1 nElement += 1
add = True add = True
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
diff_geom = QgsGeometry( geom ) diff_geom = QgsGeometry( geom )
atMap = inFeatA.attributeMap() atMap = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if diff_geom.intersects( tmpGeom ): if diff_geom.intersects( tmpGeom ):
@ -882,7 +870,7 @@ class geoprocessingThread( QThread ):
if add: if add:
try: try:
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -894,11 +882,7 @@ class geoprocessingThread( QThread ):
GEOS_EXCEPT = True GEOS_EXCEPT = True
FEATURE_EXCEPT = True FEATURE_EXCEPT = True
vproviderA = self.vlayerA.dataProvider() vproviderA = self.vlayerA.dataProvider()
allAttrsA = vproviderA.attributeIndexes()
vproviderA.select( allAttrsA )
vproviderB = self.vlayerB.dataProvider() vproviderB = self.vlayerB.dataProvider()
allAttrsB = vproviderB.attributeIndexes()
vproviderB.select( allAttrsB )
# check for crs compatibility # check for crs compatibility
crsA = vproviderA.crs() crsA = vproviderA.crs()
@ -925,8 +909,6 @@ class geoprocessingThread( QThread ):
nElement = 0 nElement = 0
index = ftools_utils.createIndex( vproviderB ) index = ftools_utils.createIndex( vproviderB )
vproviderB.rewind()
vproviderB.select( allAttrsB )
# there is selection in input layer # there is selection in input layer
if self.mySelectionA: if self.mySelectionA:
@ -941,15 +923,15 @@ class geoprocessingThread( QThread ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
atMapA = inFeatA.attributeMap() atMapA = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
if id in selectionB: if id in selectionB:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if geom.intersects( tmpGeom ): if geom.intersects( tmpGeom ):
atMapB = inFeatB.attributeMap() atMapB = inFeatB.attributes()
int_geom = QgsGeometry( geom.intersection( tmpGeom ) ) int_geom = QgsGeometry( geom.intersection( tmpGeom ) )
if int_geom.wkbType() == 0: if int_geom.wkbType() == 0:
int_com = geom.combine( tmpGeom ) int_com = geom.combine( tmpGeom )
@ -963,7 +945,7 @@ class geoprocessingThread( QThread ):
gList = ftools_utils.getGeomType( geom.wkbType() ) gList = ftools_utils.getGeomType( geom.wkbType() )
if int_geom.wkbType() in gList: if int_geom.wkbType() in gList:
outFeat.setGeometry( int_geom ) outFeat.setGeometry( int_geom )
outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) ) outFeat.setAttributes( atMapA.extend( atMapB ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -977,14 +959,14 @@ class geoprocessingThread( QThread ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
atMapA = inFeatA.attributeMap() atMapA = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if geom.intersects( tmpGeom ): if geom.intersects( tmpGeom ):
atMapB = inFeatB.attributeMap() atMapB = inFeatB.attributes()
int_geom = QgsGeometry( geom.intersection( tmpGeom ) ) int_geom = QgsGeometry( geom.intersection( tmpGeom ) )
if int_geom.wkbType() == 0: if int_geom.wkbType() == 0:
int_com = geom.combine( tmpGeom ) int_com = geom.combine( tmpGeom )
@ -994,7 +976,7 @@ class geoprocessingThread( QThread ):
gList = ftools_utils.getGeomType( geom.wkbType() ) gList = ftools_utils.getGeomType( geom.wkbType() )
if int_geom.wkbType() in gList: if int_geom.wkbType() in gList:
outFeat.setGeometry( int_geom ) outFeat.setGeometry( int_geom )
outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) ) outFeat.setAttributes( atMapA.extend( atMapB ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
EATURE_EXCEPT = False EATURE_EXCEPT = False
@ -1007,24 +989,23 @@ class geoprocessingThread( QThread ):
nFeat = vproviderA.featureCount() nFeat = vproviderA.featureCount()
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0)
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
vproviderA.rewind()
vproviderA.select( allAttrsA )
# we have selection in overlay layer # we have selection in overlay layer
if self.mySelectionB: if self.mySelectionB:
selectionB = self.vlayerB.selectedFeaturesIds() selectionB = self.vlayerB.selectedFeaturesIds()
while vproviderA.nextFeature( inFeatA ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeatA ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
atMapA = inFeatA.attributeMap() atMapA = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
if id in selectionB: if id in selectionB:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if geom.intersects( tmpGeom ): if geom.intersects( tmpGeom ):
atMapB = inFeatB.attributeMap() atMapB = inFeatB.attributes()
int_geom = QgsGeometry( geom.intersection( tmpGeom ) ) int_geom = QgsGeometry( geom.intersection( tmpGeom ) )
if int_geom.wkbType() == 0: if int_geom.wkbType() == 0:
int_com = geom.combine( tmpGeom ) int_com = geom.combine( tmpGeom )
@ -1034,7 +1015,7 @@ class geoprocessingThread( QThread ):
gList = ftools_utils.getGeomType( geom.wkbType() ) gList = ftools_utils.getGeomType( geom.wkbType() )
if int_geom.wkbType() in gList: if int_geom.wkbType() in gList:
outFeat.setGeometry( int_geom ) outFeat.setGeometry( int_geom )
outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) ) outFeat.setAttributes( atMapA.extend( atMapB ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -1044,18 +1025,19 @@ class geoprocessingThread( QThread ):
break break
# we have no selection in overlay layer # we have no selection in overlay layer
else: else:
while vproviderA.nextFeature( inFeatA ): fitA = vproviderA.getFeatures()
while fita.nextFeature( inFeatA ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
atMapA = inFeatA.attributeMap() atMapA = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if geom.intersects( tmpGeom ): if geom.intersects( tmpGeom ):
atMapB = inFeatB.attributeMap() atMapB = inFeatB.attributes()
int_geom = QgsGeometry( geom.intersection( tmpGeom ) ) int_geom = QgsGeometry( geom.intersection( tmpGeom ) )
if int_geom.wkbType() == 0: if int_geom.wkbType() == 0:
int_com = geom.combine( tmpGeom ) int_com = geom.combine( tmpGeom )
@ -1065,7 +1047,7 @@ class geoprocessingThread( QThread ):
gList = ftools_utils.getGeomType( geom.wkbType() ) gList = ftools_utils.getGeomType( geom.wkbType() )
if int_geom.wkbType() in gList: if int_geom.wkbType() in gList:
outFeat.setGeometry( int_geom ) outFeat.setGeometry( int_geom )
outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) ) outFeat.setAttributes( atMapA.extend( atMapB ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -1080,11 +1062,7 @@ class geoprocessingThread( QThread ):
GEOS_EXCEPT = True GEOS_EXCEPT = True
FEATURE_EXCEPT = True FEATURE_EXCEPT = True
vproviderA = self.vlayerA.dataProvider() vproviderA = self.vlayerA.dataProvider()
allAttrsA = vproviderA.attributeIndexes()
vproviderA.select( allAttrsA )
vproviderB = self.vlayerB.dataProvider() vproviderB = self.vlayerB.dataProvider()
allAttrsB = vproviderB.attributeIndexes()
vproviderB.select( allAttrsB )
# check for crs compatibility # check for crs compatibility
crsA = vproviderA.crs() crsA = vproviderA.crs()
@ -1110,10 +1088,6 @@ class geoprocessingThread( QThread ):
outFeat = QgsFeature() outFeat = QgsFeature()
indexA = ftools_utils.createIndex( vproviderB ) indexA = ftools_utils.createIndex( vproviderB )
indexB = ftools_utils.createIndex( vproviderA ) indexB = ftools_utils.createIndex( vproviderA )
vproviderA.rewind()
vproviderA.select( allAttrsA )
vproviderB.rewind()
vproviderB.select(allAttrsB)
nFeat = vproviderA.featureCount() * vproviderB.featureCount() nFeat = vproviderA.featureCount() * vproviderB.featureCount()
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0)
@ -1122,18 +1096,19 @@ class geoprocessingThread( QThread ):
count = 0 count = 0
nElement = 0 nElement = 0
while vproviderA.nextFeature( inFeatA ): fitA = vproviderA.getFeatures()
while fit.nextFeature( inFeatA ):
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
nElement += 1 nElement += 1
found = False found = False
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
diff_geom = QgsGeometry( geom ) diff_geom = QgsGeometry( geom )
atMapA = inFeatA.attributeMap() atMapA = inFeatA.attributes()
intersects = indexA.intersects( geom.boundingBox() ) intersects = indexA.intersects( geom.boundingBox() )
if len( intersects ) < 1: if len( intersects ) < 1:
try: try:
outFeat.setGeometry( geom ) outFeat.setGeometry( geom )
outFeat.setAttributeMap( atMapA ) outFeat.setAttributes( atMapA )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
# this really shouldn't happen, as we # this really shouldn't happen, as we
@ -1142,8 +1117,8 @@ class geoprocessingThread( QThread ):
else: else:
for id in intersects: for id in intersects:
count += 1 count += 1
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
atMapB = inFeatB.attributeMap() atMapB = inFeatB.attributes()
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if geom.intersects( tmpGeom ): if geom.intersects( tmpGeom ):
@ -1173,7 +1148,7 @@ class geoprocessingThread( QThread ):
int_geom = QgsGeometry( i ) int_geom = QgsGeometry( i )
try: try:
outFeat.setGeometry( int_geom ) outFeat.setGeometry( int_geom )
outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) ) outFeat.setAttributes( atMapA.extend( atMapB ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except Exception, err: except Exception, err:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -1186,7 +1161,7 @@ class geoprocessingThread( QThread ):
if int_geom.wkbType() in gList: if int_geom.wkbType() in gList:
try: try:
outFeat.setGeometry( int_geom ) outFeat.setGeometry( int_geom )
outFeat.setAttributeMap( ftools_utils.combineVectorAttributes( atMapA, atMapB ) ) outFeat.setAttributes( atMapA.extend( atMapB ) )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except Exception, err: except Exception, err:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -1195,7 +1170,7 @@ class geoprocessingThread( QThread ):
# intersects, but the geometry doesn't # intersects, but the geometry doesn't
try: try:
outFeat.setGeometry( geom ) outFeat.setGeometry( geom )
outFeat.setAttributeMap( atMapA ) outFeat.setAttributes( atMapA )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
# also shoudn't ever happen # also shoudn't ever happen
@ -1212,33 +1187,32 @@ class geoprocessingThread( QThread ):
if i.type() == geom.type(): if i.type() == geom.type():
diff_geom = QgsGeometry( i ) diff_geom = QgsGeometry( i )
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMapA ) outFeat.setAttributes( atMapA )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except Exception, err: except Exception, err:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
length = len( vproviderA.fields().values() ) length = len( vproviderA.fields().values() )
vproviderB.rewind()
vproviderB.select(allAttrsB)
while vproviderB.nextFeature( inFeatA ): fitB = vproviderB.getFeatures()
while fitB.nextFeature( inFeatA ):
add = False add = False
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
diff_geom = QgsGeometry( geom ) diff_geom = QgsGeometry( geom )
atMap = inFeatA.attributeMap().values() atMap = inFeatA.attributes()
atMap = dict( zip( range( length, length + len( atMap ) ), atMap ) ) atMap = dict( zip( range( length, length + len( atMap ) ), atMap ) )
intersects = indexB.intersects( geom.boundingBox() ) intersects = indexB.intersects( geom.boundingBox() )
if len(intersects) < 1: if len(intersects) < 1:
try: try:
outFeat.setGeometry( geom ) outFeat.setGeometry( geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except Exception, err: except Exception, err:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
else: else:
for id in intersects: for id in intersects:
vproviderA.featureAtId( int( id ), inFeatB , True, allAttrsA ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
@ -1249,7 +1223,7 @@ class geoprocessingThread( QThread ):
# this only happends if the bounding box # this only happends if the bounding box
# intersects, but the geometry doesn't # intersects, but the geometry doesn't
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except Exception, err: except Exception, err:
add = False add = False
@ -1258,7 +1232,7 @@ class geoprocessingThread( QThread ):
if add: if add:
try: try:
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except Exception, err: except Exception, err:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -1271,12 +1245,6 @@ class geoprocessingThread( QThread ):
def symetrical_difference( self ): def symetrical_difference( self ):
GEOS_EXCEPT = True GEOS_EXCEPT = True
FEATURE_EXCEPT = True FEATURE_EXCEPT = True
vproviderA = self.vlayerA.dataProvider()
allAttrsA = vproviderA.attributeIndexes()
vproviderA.select( allAttrsA )
vproviderB = self.vlayerB.dataProvider()
allAttrsB = vproviderB.attributeIndexes()
vproviderB.select( allAttrsB )
# check for crs compatibility # check for crs compatibility
crsA = vproviderA.crs() crsA = vproviderA.crs()
@ -1303,25 +1271,22 @@ class geoprocessingThread( QThread ):
indexA = ftools_utils.createIndex( vproviderB ) indexA = ftools_utils.createIndex( vproviderB )
indexB = ftools_utils.createIndex( vproviderA ) indexB = ftools_utils.createIndex( vproviderA )
vproviderA.rewind()
vproviderA.select( allAttrsA )
vproviderB.rewind()
vproviderB.select(allAttrsB)
nFeat = vproviderA.featureCount() * vproviderB.featureCount() nFeat = vproviderA.featureCount() * vproviderB.featureCount()
nElement = 0 nElement = 0
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0)
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
while vproviderA.nextFeature( inFeatA ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeatA ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
add = True add = True
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
diff_geom = QgsGeometry( geom ) diff_geom = QgsGeometry( geom )
atMapA = inFeatA.attributeMap() atMapA = inFeatA.attributes()
intersects = indexA.intersects( geom.boundingBox() ) intersects = indexA.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if diff_geom.intersects( tmpGeom ): if diff_geom.intersects( tmpGeom ):
@ -1333,27 +1298,26 @@ class geoprocessingThread( QThread ):
if add: if add:
try: try:
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMapA ) outFeat.setAttributes( atMapA )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
continue continue
length = len( vproviderA.fields().values() ) length = len( vproviderA.fields() )
vproviderB.rewind()
vproviderB.select(allAttrsB)
while vproviderB.nextFeature( inFeatA ): fitB = vproviderB.getFeatures()
while fitB.nextFeature( inFeatA ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
add = True add = True
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
diff_geom = QgsGeometry( geom ) diff_geom = QgsGeometry( geom )
atMap = inFeatA.attributeMap().values() atMap = inFeatA.attributes()
atMap = dict( zip( range( length, length + len( atMap ) ), atMap ) ) atMap = dict( zip( range( length, length + len( atMap ) ), atMap ) )
intersects = indexB.intersects( geom.boundingBox() ) intersects = indexB.intersects( geom.boundingBox() )
for id in intersects: for id in intersects:
vproviderA.featureAtId( int( id ), inFeatB , True, allAttrsA ) vproviderA.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
try: try:
if diff_geom.intersects( tmpGeom ): if diff_geom.intersects( tmpGeom ):
@ -1365,7 +1329,7 @@ class geoprocessingThread( QThread ):
if add: if add:
try: try:
outFeat.setGeometry( diff_geom ) outFeat.setGeometry( diff_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEATURE_EXCEPT = False FEATURE_EXCEPT = False
@ -1376,12 +1340,6 @@ class geoprocessingThread( QThread ):
def clip( self ): def clip( self ):
GEOS_EXCEPT = True GEOS_EXCEPT = True
FEATURE_EXCEPT = True FEATURE_EXCEPT = True
vproviderA = self.vlayerA.dataProvider()
allAttrsA = vproviderA.attributeIndexes()
vproviderA.select( allAttrsA )
vproviderB = self.vlayerB.dataProvider()
allAttrsB = vproviderB.attributeIndexes()
vproviderB.select( allAttrsB )
# check for crs compatibility # check for crs compatibility
crsA = vproviderA.crs() crsA = vproviderA.crs()
@ -1391,8 +1349,7 @@ class geoprocessingThread( QThread ):
else: else:
crs_match = crsA == crsB crs_match = crsA == crsB
fields = vproviderA.fields() writer = QgsVectorFileWriter( self.myName, self.myEncoding, vproviderA.fields(),
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
vproviderA.geometryType(), vproviderA.crs() ) vproviderA.geometryType(), vproviderA.crs() )
if writer.hasError(): if writer.hasError():
return GEOS_EXCEPT, FEATURE_EXCEPT, crs_match, writer.errorMessage() return GEOS_EXCEPT, FEATURE_EXCEPT, crs_match, writer.errorMessage()
@ -1402,10 +1359,7 @@ class geoprocessingThread( QThread ):
outFeat = QgsFeature() outFeat = QgsFeature()
index = ftools_utils.createIndex( vproviderB ) index = ftools_utils.createIndex( vproviderB )
vproviderA.rewind()
vproviderA.select( allAttrsA )
vproviderB.rewind()
vproviderB.select( allAttrsB )
nElement = 0 nElement = 0
# there is selection in input layer # there is selection in input layer
@ -1422,13 +1376,13 @@ class geoprocessingThread( QThread ):
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
int_geom = QgsGeometry( geom ) int_geom = QgsGeometry( geom )
atMap = inFeatA.attributeMap() atMap = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
found = False found = False
first = True first = True
for id in intersects: for id in intersects:
if id in selectionB: if id in selectionB:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
if tmpGeom.intersects( geom ): if tmpGeom.intersects( geom ):
found = True found = True
@ -1453,7 +1407,7 @@ class geoprocessingThread( QThread ):
new_geom = QgsGeometry( int_com.difference( int_sym ) ) new_geom = QgsGeometry( int_com.difference( int_sym ) )
try: try:
outFeat.setGeometry( new_geom ) outFeat.setGeometry( new_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEAT_EXCEPT = False FEAT_EXCEPT = False
@ -1467,12 +1421,12 @@ class geoprocessingThread( QThread ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
atMap = inFeatA.attributeMap() atMap = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
found = False found = False
first = True first = True
for id in intersects: for id in intersects:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
if tmpGeom.intersects( geom ): if tmpGeom.intersects( geom ):
found = True found = True
@ -1497,7 +1451,7 @@ class geoprocessingThread( QThread ):
new_geom = QgsGeometry( int_com.difference( int_sym ) ) new_geom = QgsGeometry( int_com.difference( int_sym ) )
try: try:
outFeat.setGeometry( new_geom ) outFeat.setGeometry( new_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEAT_EXCEPT = False FEAT_EXCEPT = False
@ -1513,17 +1467,18 @@ class geoprocessingThread( QThread ):
# we have selection in overlay layer # we have selection in overlay layer
if self.mySelectionB: if self.mySelectionB:
selectionB = self.vlayerB.selectedFeaturesIds() selectionB = self.vlayerB.selectedFeaturesIds()
while vproviderA.nextFeature( inFeatA ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeatA ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
atMap = inFeatA.attributeMap() atMap = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
found = False found = False
first = True first = True
for id in intersects: for id in intersects:
if id in selectionB: if id in selectionB:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
if tmpGeom.intersects( geom ): if tmpGeom.intersects( geom ):
found = True found = True
@ -1548,7 +1503,7 @@ class geoprocessingThread( QThread ):
new_geom = QgsGeometry( int_com.difference( int_sym ) ) new_geom = QgsGeometry( int_com.difference( int_sym ) )
try: try:
outFeat.setGeometry( new_geom ) outFeat.setGeometry( new_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEAT_EXCEPT = False FEAT_EXCEPT = False
@ -1558,17 +1513,18 @@ class geoprocessingThread( QThread ):
continue continue
# we have no selection in overlay layer # we have no selection in overlay layer
else: else:
while vproviderA.nextFeature( inFeatA ): fitA = vproviderA.getFeatures()
while fitA.nextFeature( inFeatA ):
nElement += 1 nElement += 1
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
geom = QgsGeometry( inFeatA.geometry() ) geom = QgsGeometry( inFeatA.geometry() )
atMap = inFeatA.attributeMap() atMap = inFeatA.attributes()
intersects = index.intersects( geom.boundingBox() ) intersects = index.intersects( geom.boundingBox() )
first = True first = True
found = False found = False
if len( intersects ) > 0: if len( intersects ) > 0:
for id in intersects: for id in intersects:
vproviderB.featureAtId( int( id ), inFeatB , True, allAttrsB ) vproviderB.getFeatures( QgsFeatureRequest().setFilterFid( int( id ) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
if tmpGeom.intersects( geom ): if tmpGeom.intersects( geom ):
found = True found = True
@ -1593,7 +1549,7 @@ class geoprocessingThread( QThread ):
new_geom = QgsGeometry( int_com.difference( int_sym ) ) new_geom = QgsGeometry( int_com.difference( int_sym ) )
try: try:
outFeat.setGeometry( new_geom ) outFeat.setGeometry( new_geom )
outFeat.setAttributeMap( atMap ) outFeat.setAttributes( atMap )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
except: except:
FEAT_EXCEPT = False FEAT_EXCEPT = False

12
python/plugins/fTools/tools/doIntersectLines.py

@ -114,7 +114,6 @@ class Dialog(QDialog, Ui_Dialog):
layer1 = ftools_utils.getVectorLayerByName(line1) layer1 = ftools_utils.getVectorLayerByName(line1)
provider1 = layer1.dataProvider() provider1 = layer1.dataProvider()
allAttrs = provider1.attributeIndexes()
fieldList = ftools_utils.getFieldList(layer1) fieldList = ftools_utils.getFieldList(layer1)
index1 = provider1.fieldNameIndex(field1) index1 = provider1.fieldNameIndex(field1)
field1 = fieldList[index1] field1 = fieldList[index1]
@ -122,7 +121,6 @@ class Dialog(QDialog, Ui_Dialog):
layer2 = ftools_utils.getVectorLayerByName(line2) layer2 = ftools_utils.getVectorLayerByName(line2)
provider2 = layer2.dataProvider() provider2 = layer2.dataProvider()
allAttrs = provider2.attributeIndexes()
fieldList = ftools_utils.getFieldList(layer2) fieldList = ftools_utils.getFieldList(layer2)
index2 = provider2.fieldNameIndex(field2) index2 = provider2.fieldNameIndex(field2)
field2 = fieldList[index2] field2 = fieldList[index2]
@ -145,16 +143,16 @@ class Dialog(QDialog, Ui_Dialog):
index = ftools_utils.createIndex( provider2 ) index = ftools_utils.createIndex( provider2 )
provider1.select([index1]) fit1 = vprovider.getFeatures( QgsFeatureRequest().setSubsetOfAttributes([index1]) )
while provider1.nextFeature(inFeat): while fit1.nextFeature(inFeat):
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
v1 = inFeat.attributeMap()[index1] v1 = inFeat.attributes()[index1]
lineList = index.intersects( inGeom.boundingBox() ) lineList = index.intersects( inGeom.boundingBox() )
for i in lineList: for i in lineList:
provider2.featureAtId( int( i ), inFeatB , True, [index2] ) provider2.getFeatures( QgsFeatureRequest().setFilterFid( int( i ) ).setSubsetOfAttributes([index2]) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
v2 = inFeatB.attributeMap()[index2] v2 = inFeatB.attributes()[index2]
if inGeom.intersects(tmpGeom): if inGeom.intersects(tmpGeom):
tempGeom = inGeom.intersection(tmpGeom) tempGeom = inGeom.intersection(tmpGeom)

11
python/plugins/fTools/tools/doMeanCoords.py

@ -116,8 +116,6 @@ class Dialog(QDialog, Ui_Dialog):
weightIndex = provider.fieldNameIndex(weightField) weightIndex = provider.fieldNameIndex(weightField)
uniqueIndex = provider.fieldNameIndex(uniqueField) uniqueIndex = provider.fieldNameIndex(uniqueField)
feat = QgsFeature() feat = QgsFeature()
allAttrs = provider.attributeIndexes()
provider.select(allAttrs)
sRs = provider.crs() sRs = provider.crs()
check = QFile(self.shapefileName) check = QFile(self.shapefileName)
if check.exists(): if check.exists():
@ -143,26 +141,25 @@ class Dialog(QDialog, Ui_Dialog):
self.progressBar.setValue(0) self.progressBar.setValue(0)
self.progressBar.setRange(0, nFeat) self.progressBar.setRange(0, nFeat)
for j in uniqueValues: for j in uniqueValues:
provider.rewind()
provider.select(allAttrs)
cx = 0.00 cx = 0.00
cy = 0.00 cy = 0.00
points = [] points = []
weights = [] weights = []
while provider.nextFeature(feat): fit = provider.getFeatures()
while fit.nextFeature(feat):
nElement += 1 nElement += 1
self.progressBar.setValue(nElement) self.progressBar.setValue(nElement)
if single: if single:
check = j.toString().trimmed() check = j.toString().trimmed()
else: else:
check = feat.attributeMap()[uniqueIndex].toString().trimmed() check = feat.attributes()[uniqueIndex].toString().trimmed()
if check == j.toString().trimmed(): if check == j.toString().trimmed():
cx = 0.00 cx = 0.00
cy = 0.00 cy = 0.00
if weightIndex == -1: if weightIndex == -1:
weight = 1.00 weight = 1.00
else: else:
weight = float(feat.attributeMap()[weightIndex].toDouble()[0]) weight = float(feat.attributes()[weightIndex].toDouble()[0])
geom = QgsGeometry(feat.geometry()) geom = QgsGeometry(feat.geometry())
geom = ftools_utils.extractPoints(geom) geom = ftools_utils.extractPoints(geom)
for i in geom: for i in geom:

57
python/plugins/fTools/tools/doMergeShapes.py

@ -240,26 +240,39 @@ class ShapeMergeThread( QThread ):
# create attribute list with uniquie fields # create attribute list with uniquie fields
# from all selected layers # from all selected layers
mergedFields = {} mergedFields = []
count = 0
self.emit( SIGNAL( "rangeChanged( PyQt_PyObject )" ), len( self.shapes ) ) self.emit( SIGNAL( "rangeChanged( PyQt_PyObject )" ), len( self.shapes ) )
self.emit( SIGNAL( "checkStarted()" ) ) self.emit( SIGNAL( "checkStarted()" ) )
shapeIndex = 0
fieldMap = {}
for fileName in self.shapes: for fileName in self.shapes:
layerPath = QFileInfo( self.baseDir + "/" + fileName ).absoluteFilePath() layerPath = QFileInfo( self.baseDir + "/" + fileName ).absoluteFilePath()
newLayer = QgsVectorLayer( layerPath, QFileInfo( layerPath ).baseName(), "ogr" ) newLayer = QgsVectorLayer( layerPath, QFileInfo( layerPath ).baseName(), "ogr" )
if not newLayer.isValid(): if not newLayer.isValid():
continue continue
vprovider = newLayer.dataProvider() vprovider = newLayer.dataProvider()
layerFields = vprovider.fields()
for layerIndex, layerField in layerFields.iteritems(): fieldIndex = 0
for layerField in vprovider.fields():
fieldFound = False fieldFound = False
for mergedIndex, mergedField in mergedFields.iteritems(): for mergedField in mergedFields:
if ( mergedField.name() == layerField.name() ) and ( mergedField.type() == layerField.type() ): if mergedField.name() == layerField.name() and mergedField.type() == layerField.type():
fieldFound = True fieldFound = True
break
if not fieldFound: if not fieldFound:
mergedFields[ count ] = layerField if not fieldMap.has_key(shapeIndex):
count += 1 fieldMap[shapeIndex]={}
fieldMap[shapeIndex][fieldIndex] = len(mergedFields)
mergedFields.append( layerField )
fieldIndex += 1
shapeIndex += 1
self.emit( SIGNAL( "featureProcessed()" ) ) self.emit( SIGNAL( "featureProcessed()" ) )
self.emit( SIGNAL( "checkFinished()" ) ) self.emit( SIGNAL( "checkFinished()" ) )
@ -269,11 +282,11 @@ class ShapeMergeThread( QThread ):
self.crs = newLayer.crs() self.crs = newLayer.crs()
self.geom = newLayer.wkbType() self.geom = newLayer.wkbType()
vprovider = newLayer.dataProvider() vprovider = newLayer.dataProvider()
self.fields = mergedFields
writer = QgsVectorFileWriter( self.outputFileName, self.outputEncoding, writer = QgsVectorFileWriter( self.outputFileName, self.outputEncoding,
self.fields, self.geom, self.crs ) mergedFields, self.geom, self.crs )
shapeIndex = 0
for fileName in self.shapes: for fileName in self.shapes:
layerPath = QFileInfo( self.baseDir + "/" + fileName ).absoluteFilePath() layerPath = QFileInfo( self.baseDir + "/" + fileName ).absoluteFilePath()
newLayer = QgsVectorLayer( layerPath, QFileInfo( layerPath ).baseName(), "ogr" ) newLayer = QgsVectorLayer( layerPath, QFileInfo( layerPath ).baseName(), "ogr" )
@ -282,25 +295,26 @@ class ShapeMergeThread( QThread ):
vprovider = newLayer.dataProvider() vprovider = newLayer.dataProvider()
vprovider.setEncoding( self.inputEncoding ) vprovider.setEncoding( self.inputEncoding )
layerFields = vprovider.fields() layerFields = vprovider.fields()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
nFeat = vprovider.featureCount() nFeat = vprovider.featureCount()
self.emit( SIGNAL( "rangeChanged( PyQt_PyObject )" ), nFeat ) self.emit( SIGNAL( "rangeChanged( PyQt_PyObject )" ), nFeat )
self.emit( SIGNAL( "fileNameChanged( PyQt_PyObject )" ), fileName ) self.emit( SIGNAL( "fileNameChanged( PyQt_PyObject )" ), fileName )
inFeat = QgsFeature() inFeat = QgsFeature()
outFeat = QgsFeature() outFeat = QgsFeature()
inGeom = QgsGeometry() inGeom = QgsGeometry()
while vprovider.nextFeature( inFeat ): fit = vprovider.getFeatures()
atMap = inFeat.attributeMap() while fit.nextFeature( inFeat ):
mergedAttrs = {} mergedAttrs = [QVariant()] * len(mergedFields)
# fill available attributes with values # fill available attributes with values
for layerIndex, layerField in layerFields.iteritems(): fieldIndex = 0
for mergedIndex, mergedField in self.fields.iteritems(): for v in inFeat.attributes():
if ( mergedField.name() == layerField.name() ) and ( mergedField.type() == layerField.type() ): if fieldMap.has_key(shapeIndex) and fieldMap[shapeIndex].has_key(layerIndex):
mergedAttrs[ mergedIndex ] = atMap[ layerIndex ] mergedAttrs[ fieldMap[shapeIndex][layerIndex] ] = v
fieldIndex += 1
inGeom = QgsGeometry( inFeat.geometry() ) inGeom = QgsGeometry( inFeat.geometry() )
outFeat.setGeometry( inGeom ) outFeat.setGeometry( inGeom )
outFeat.setAttributeMap( mergedAttrs ) outFeat.setAttributes( mergedAttrs )
writer.addFeature( outFeat ) writer.addFeature( outFeat )
self.emit( SIGNAL( "featureProcessed()" ) ) self.emit( SIGNAL( "featureProcessed()" ) )
@ -308,10 +322,13 @@ class ShapeMergeThread( QThread ):
self.mutex.lock() self.mutex.lock()
s = self.stopMe s = self.stopMe
self.mutex.unlock() self.mutex.unlock()
if s == 1: if s == 1:
interrupted = True interrupted = True
break break
shapeIndex += 1
del writer del writer
if not interrupted: if not interrupted:

30
python/plugins/fTools/tools/doPointDistance.py

@ -1,4 +1,4 @@
# -*- coding: utf-8 -*-
#----------------------------------------------------------- #-----------------------------------------------------------
# #
# fTools # fTools
@ -158,15 +158,11 @@ class Dialog(QDialog, Ui_Dialog):
layer2 = ftools_utils.getVectorLayerByName(line2) layer2 = ftools_utils.getVectorLayerByName(line2)
provider1 = layer1.dataProvider() provider1 = layer1.dataProvider()
provider2 = layer2.dataProvider() provider2 = layer2.dataProvider()
allAttrs = provider1.attributeIndexes()
provider1.select(allAttrs)
allAttrs = provider2.attributeIndexes()
provider2.select(allAttrs)
sindex = QgsSpatialIndex() sindex = QgsSpatialIndex()
inFeat = QgsFeature() inFeat = QgsFeature()
while provider2.nextFeature(inFeat): fit2 = provider2.getFeatures()
while fit2.nextFeature(inFeat):
sindex.insertFeature(inFeat) sindex.insertFeature(inFeat)
provider2.rewind()
if nearest < 1: nearest = layer2.featureCount() if nearest < 1: nearest = layer2.featureCount()
else: nearest = nearest else: nearest = nearest
index1 = provider1.fieldNameIndex(field1) index1 = provider1.fieldNameIndex(field1)
@ -196,20 +192,21 @@ class Dialog(QDialog, Ui_Dialog):
first = True first = True
start = 15.00 start = 15.00
add = 85.00 / provider1.featureCount() add = 85.00 / provider1.featureCount()
while provider1.nextFeature(inFeat): fit1 = provider1.getFeatures()
while fit1.nextFeature(inFeat):
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
inID = inFeat.attributeMap()[index1].toString() inID = inFeat.attributes()[index1].toString()
if first: if first:
featList = sindex.nearestNeighbor(inGeom.asPoint(), nearest) featList = sindex.nearestNeighbor(inGeom.asPoint(), nearest)
first = False first = False
data = ["ID"] data = ["ID"]
for i in featList: for i in featList:
provider2.featureAtId(int(i), outFeat, True, [index2]) provider2.getFeatures( QgsFeatureRequest().setFilterFid( int(i) ).setSubsetOfAttributes([index2]) ).nextFeature( outFeat )
data.append(unicode(outFeat.attributeMap()[index2].toString())) data.append(unicode(outFeat.attributes()[index2].toString()))
writer.writerow(data) writer.writerow(data)
data = [unicode(inID)] data = [unicode(inID)]
for j in featList: for j in featList:
provider2.featureAtId(int(j), outFeat, True) provider2.getFeatures( QgsFeatureRequest().setFilterFid( int(j) ) ).nextFeature( outFeat )
outGeom = outFeat.geometry() outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(), outGeom.asPoint()) dist = distArea.measureLine(inGeom.asPoint(), outGeom.asPoint())
data.append(str(float(dist))) data.append(str(float(dist)))
@ -225,15 +222,16 @@ class Dialog(QDialog, Ui_Dialog):
outGeom = QgsGeometry() outGeom = QgsGeometry()
start = 15.00 start = 15.00
add = 85.00 / provider1.featureCount() add = 85.00 / provider1.featureCount()
while provider1.nextFeature(inFeat): fit1 = provider1.getFeatures()
while fit1.nextFeature(inFeat):
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
inID = inFeat.attributeMap()[index1].toString() inID = inFeat.attributes()[index1].toString()
featList = sindex.nearestNeighbor(inGeom.asPoint(), nearest) featList = sindex.nearestNeighbor(inGeom.asPoint(), nearest)
distList = [] distList = []
vari = 0.00 vari = 0.00
for i in featList: for i in featList:
provider2.featureAtId(int(i), outFeat, True, [index2]) provider2.getFeatures( QgsFeatureRequest().setFilterFid( int(i) ).setSubsetOfAttributes([index2]) ).nextFeature( outFeat )
outID = outFeat.attributeMap()[index2].toString() outID = outFeat.attributes()[index2].toString()
outGeom = outFeat.geometry() outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(), outGeom.asPoint()) dist = distArea.measureLine(inGeom.asPoint(), outGeom.asPoint())
if dist > 0: if dist > 0:

14
python/plugins/fTools/tools/doPointsInPolygon.py

@ -166,9 +166,6 @@ class PointsInPolygonThread(QThread):
polyProvider = self.layerPoly.dataProvider() polyProvider = self.layerPoly.dataProvider()
pointProvider = self.layerPoints.dataProvider() pointProvider = self.layerPoints.dataProvider()
allAttrs = polyProvider.attributeIndexes()
polyProvider.select(allAttrs)
fieldList = ftools_utils.getFieldList(self.layerPoly) fieldList = ftools_utils.getFieldList(self.layerPoly)
index = polyProvider.fieldNameIndex(unicode(self.fieldName)) index = polyProvider.fieldNameIndex(unicode(self.fieldName))
if index == -1: if index == -1:
@ -185,8 +182,6 @@ class PointsInPolygonThread(QThread):
polyProvider.geometryType(), sRs) polyProvider.geometryType(), sRs)
spatialIndex = ftools_utils.createIndex( pointProvider ) spatialIndex = ftools_utils.createIndex( pointProvider )
pointProvider.rewind()
pointProvider.select()
self.emit(SIGNAL("rangeChanged(int)"), polyProvider.featureCount() ) self.emit(SIGNAL("rangeChanged(int)"), polyProvider.featureCount() )
@ -194,10 +189,11 @@ class PointsInPolygonThread(QThread):
pntFeat = QgsFeature() pntFeat = QgsFeature()
outFeat = QgsFeature() outFeat = QgsFeature()
inGeom = QgsGeometry() inGeom = QgsGeometry()
while polyProvider.nextFeature(polyFeat): polyFit = polyProvider.getFeatures()
while polyFit.nextFeature(polyFeat):
inGeom = polyFeat.geometry() inGeom = polyFeat.geometry()
atMap = polyFeat.attributeMap() atMap = polyFeat.attributes()
outFeat.setAttributeMap(atMap) outFeat.setAttributes(atMap)
outFeat.setGeometry(inGeom) outFeat.setGeometry(inGeom)
count = 0 count = 0
@ -211,7 +207,7 @@ class PointsInPolygonThread(QThread):
if hasIntersection: if hasIntersection:
for p in pointList: for p in pointList:
pointProvider.featureAtId(p, pntFeat , True) pointProvider.getFeatures( QgsFeatureRequest().setFilterFid( p ) ).nextFeature( pntFeat )
tmpGeom = QgsGeometry(pntFeat.geometry()) tmpGeom = QgsGeometry(pntFeat.geometry())
if inGeom.intersects(tmpGeom): if inGeom.intersects(tmpGeom):
count += 1 count += 1

18
python/plugins/fTools/tools/doRandPoints.py

@ -143,19 +143,16 @@ class Dialog(QDialog, Ui_Dialog):
# combine all polygons in layer to create single polygon (slow for complex polygons) # combine all polygons in layer to create single polygon (slow for complex polygons)
def createSinglePolygon(self, vlayer): def createSinglePolygon(self, vlayer):
provider = vlayer.dataProvider() provider = vlayer.dataProvider()
allAttrs = provider.attributeIndexes()
provider.select(allAttrs)
feat = QgsFeature() feat = QgsFeature()
geom = QgsGeometry() geom = QgsGeometry()
#geom2 = QgsGeometry() #geom2 = QgsGeometry()
provider.nextFeature(feat) fit = provider.getFeatures()
fit.nextFeature(feat)
geom = QgsGeometry(feat.geometry()) geom = QgsGeometry(feat.geometry())
count = 10.00 count = 10.00
add = ( 40.00 - 10.00 ) / provider.featureCount() add = ( 40.00 - 10.00 ) / provider.featureCount()
#provider.rewind()
#provider.nextFeature(feat)
#geom = QgsGeometry(feat.geometry()) #geom = QgsGeometry(feat.geometry())
while provider.nextFeature(feat): while fit.nextFeature(feat):
geom = geom.combine(QgsGeometry( feat.geometry() )) geom = geom.combine(QgsGeometry( feat.geometry() ))
count = count + add count = count + add
self.progressBar.setValue(count) self.progressBar.setValue(count)
@ -194,7 +191,7 @@ class Dialog(QDialog, Ui_Dialog):
pGeom = QgsGeometry().fromPoint(point) pGeom = QgsGeometry().fromPoint(point)
ids = index.intersects(pGeom.buffer(5,5).boundingBox()) ids = index.intersects(pGeom.buffer(5,5).boundingBox())
for id in ids: for id in ids:
provider.featureAtId(int(id),feat,True) provider.getFeatures( QgsFeatureRequest().setFilterFid( int(id) ) ).nextFeature( feat )
tGeom = QgsGeometry(feat.geometry()) tGeom = QgsGeometry(feat.geometry())
if pGeom.intersects(tGeom): if pGeom.intersects(tGeom):
points.append(pGeom) points.append(pGeom)
@ -238,8 +235,6 @@ class Dialog(QDialog, Ui_Dialog):
# #
def loopThruPolygons(self, inLayer, numRand, design): def loopThruPolygons(self, inLayer, numRand, design):
sProvider = inLayer.dataProvider() sProvider = inLayer.dataProvider()
sAllAttrs = sProvider.attributeIndexes()
sProvider.select(sAllAttrs)
sFeat = QgsFeature() sFeat = QgsFeature()
sGeom = QgsGeometry() sGeom = QgsGeometry()
sPoints = [] sPoints = []
@ -250,13 +245,14 @@ class Dialog(QDialog, Ui_Dialog):
break break
count = 10.00 count = 10.00
add = 60.00 / sProvider.featureCount() add = 60.00 / sProvider.featureCount()
while sProvider.nextFeature(sFeat): sFit = sProvider.getFeatures()
while sFit.nextFeature(sFeat):
sGeom = sFeat.geometry() sGeom = sFeat.geometry()
if design == self.tr("density"): if design == self.tr("density"):
sDistArea = QgsDistanceArea() sDistArea = QgsDistanceArea()
value = int(round(numRand * sDistArea.measure(sGeom))) value = int(round(numRand * sDistArea.measure(sGeom)))
elif design == self.tr("field"): elif design == self.tr("field"):
sAtMap = sFeat.attributeMap() sAtMap = sFeat.attributes()
value = sAtMap[index].toInt()[0] value = sAtMap[index].toInt()[0]
else: else:
value = numRand value = numRand

11
python/plugins/fTools/tools/doSelectByLocation.py

@ -97,11 +97,7 @@ class Dialog(QDialog, Ui_Dialog):
inputLayer = ftools_utils.getVectorLayerByName(inPoly) inputLayer = ftools_utils.getVectorLayerByName(inPoly)
selectLayer = ftools_utils.getVectorLayerByName(inPts) selectLayer = ftools_utils.getVectorLayerByName(inPts)
inputProvider = inputLayer.dataProvider() inputProvider = inputLayer.dataProvider()
allAttrs = inputProvider.attributeIndexes()
inputProvider.select(allAttrs, QgsRectangle())
selectProvider = selectLayer.dataProvider() selectProvider = selectLayer.dataProvider()
allAttrs = selectProvider.attributeIndexes()
selectProvider.select(allAttrs, QgsRectangle())
feat = QgsFeature() feat = QgsFeature()
infeat = QgsFeature() infeat = QgsFeature()
geom = QgsGeometry() geom = QgsGeometry()
@ -116,18 +112,19 @@ class Dialog(QDialog, Ui_Dialog):
geom = QgsGeometry(feat.geometry()) geom = QgsGeometry(feat.geometry())
intersects = index.intersects(geom.boundingBox()) intersects = index.intersects(geom.boundingBox())
for id in intersects: for id in intersects:
inputProvider.featureAtId(int(id), infeat, True) inputProvider.getFeatures( QgsFeatureRequest().setFilterFid( int(id) ) ).nextFeature( infeat )
tmpGeom = QgsGeometry(infeat.geometry()) tmpGeom = QgsGeometry(infeat.geometry())
if geom.intersects(tmpGeom): if geom.intersects(tmpGeom):
selectedSet.append(infeat.id()) selectedSet.append(infeat.id())
self.progressBar.setValue(self.progressBar.value()+1) self.progressBar.setValue(self.progressBar.value()+1)
else: else:
self.progressBar.setMaximum(selectProvider.featureCount()) self.progressBar.setMaximum(selectProvider.featureCount())
while selectProvider.nextFeature(feat): selectFit = selectProvider.getFeatures()
while selectFit.nextFeature(feat):
geom = QgsGeometry(feat.geometry()) geom = QgsGeometry(feat.geometry())
intersects = index.intersects(geom.boundingBox()) intersects = index.intersects(geom.boundingBox())
for id in intersects: for id in intersects:
inputProvider.featureAtId(int(id), infeat, True) inputProvider.getFeatures( QgsFeatureRequest().setFilterFid( int(id) ) ).nextFeature( infeat )
tmpGeom = QgsGeometry( infeat.geometry() ) tmpGeom = QgsGeometry( infeat.geometry() )
if geom.intersects(tmpGeom): if geom.intersects(tmpGeom):
selectedSet.append(infeat.id()) selectedSet.append(infeat.id())

32
python/plugins/fTools/tools/doSimplify.py

@ -270,8 +270,6 @@ class GeomThread( QThread ):
if self.writeShape: if self.writeShape:
vProvider = self.inputLayer.dataProvider() vProvider = self.inputLayer.dataProvider()
allAttrs = vProvider.attributeIndexes()
vProvider.select( allAttrs )
shapeFields = vProvider.fields() shapeFields = vProvider.fields()
crs = vProvider.crs() crs = vProvider.crs()
wkbType = self.inputLayer.wkbType() wkbType = self.inputLayer.wkbType()
@ -284,7 +282,7 @@ class GeomThread( QThread ):
self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), len( selection ) ) self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), len( selection ) )
for f in selection: for f in selection:
featGeometry = QgsGeometry( f.geometry() ) featGeometry = QgsGeometry( f.geometry() )
attrMap = f.attributeMap() attrMap = f.attributes()
pointsBefore += geomVertexCount( featGeometry ) pointsBefore += geomVertexCount( featGeometry )
newGeometry = featGeometry.simplify( self.tolerance ) newGeometry = featGeometry.simplify( self.tolerance )
@ -292,7 +290,7 @@ class GeomThread( QThread ):
feature = QgsFeature() feature = QgsFeature()
feature.setGeometry( newGeometry ) feature.setGeometry( newGeometry )
feature.setAttributeMap( attrMap ) feature.setAttributes( attrMap )
shapeFileWriter.addFeature( feature ) shapeFileWriter.addFeature( feature )
featureId += 1 featureId += 1
self.emit( SIGNAL( "featureProcessed()" ) ) self.emit( SIGNAL( "featureProcessed()" ) )
@ -306,9 +304,10 @@ class GeomThread( QThread ):
else: else:
self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), vProvider.featureCount() ) self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), vProvider.featureCount() )
f = QgsFeature() f = QgsFeature()
while vProvider.nextFeature( f ): fit = vProvider.getFeatures()
while fit.nextFeature( f ):
featGeometry = QgsGeometry( f.geometry() ) featGeometry = QgsGeometry( f.geometry() )
attrMap = f.attributeMap() attrMap = f.attributes()
pointsBefore += geomVertexCount( featGeometry ) pointsBefore += geomVertexCount( featGeometry )
newGeometry = featGeometry.simplify( self.tolerance ) newGeometry = featGeometry.simplify( self.tolerance )
@ -316,7 +315,7 @@ class GeomThread( QThread ):
feature = QgsFeature() feature = QgsFeature()
feature.setGeometry( newGeometry ) feature.setGeometry( newGeometry )
feature.setAttributeMap( attrMap ) feature.setAttributes( attrMap )
shapeFileWriter.addFeature( feature ) shapeFileWriter.addFeature( feature )
featureId += 1 featureId += 1
self.emit( SIGNAL( "featureProcessed()" ) ) self.emit( SIGNAL( "featureProcessed()" ) )
@ -355,7 +354,8 @@ class GeomThread( QThread ):
vProvider = self.inputLayer.dataProvider() vProvider = self.inputLayer.dataProvider()
self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), vProvider.featureCount() ) self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), vProvider.featureCount() )
f = QgsFeature() f = QgsFeature()
while vProvider.nextFeature( f ): fit = vProvider.getFeatures()
while fit.nextFeature( f ):
featureId = f.id() featureId = f.id()
featGeometry = QgsGeometry( f.geometry() ) featGeometry = QgsGeometry( f.geometry() )
@ -399,8 +399,6 @@ class GeomThread( QThread ):
if self.writeShape: if self.writeShape:
# prepare writer # prepare writer
vProvider = self.inputLayer.dataProvider() vProvider = self.inputLayer.dataProvider()
allAttrs = vProvider.attributeIndexes()
vProvider.select( allAttrs )
shapeFields = vProvider.fields() shapeFields = vProvider.fields()
crs = vProvider.crs() crs = vProvider.crs()
wkbType = self.inputLayer.wkbType() wkbType = self.inputLayer.wkbType()
@ -414,12 +412,12 @@ class GeomThread( QThread ):
self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), len( selection ) ) self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), len( selection ) )
for f in selection: for f in selection:
featGeometry = QgsGeometry( f.geometry() ) featGeometry = QgsGeometry( f.geometry() )
attrMap = f.attributeMap() attrMap = f.attributes()
newGeometry = densifyGeometry( featGeometry, int( self.tolerance ), isPolygon ) newGeometry = densifyGeometry( featGeometry, int( self.tolerance ), isPolygon )
feature = QgsFeature() feature = QgsFeature()
feature.setGeometry( newGeometry ) feature.setGeometry( newGeometry )
feature.setAttributeMap( attrMap ) feature.setAttributes( attrMap )
shapeFileWriter.addFeature( feature ) shapeFileWriter.addFeature( feature )
featureId += 1 featureId += 1
self.emit( SIGNAL( "featureProcessed()" ) ) self.emit( SIGNAL( "featureProcessed()" ) )
@ -433,14 +431,15 @@ class GeomThread( QThread ):
else: else:
self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), vProvider.featureCount() ) self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), vProvider.featureCount() )
f = QgsFeature() f = QgsFeature()
while vProvider.nextFeature( f ): fit = vProvider.getFeatures()
while fit.nextFeature( f ):
featGeometry = QgsGeometry( f.geometry() ) featGeometry = QgsGeometry( f.geometry() )
attrMap = f.attributeMap() attrMap = f.attributes()
newGeometry = densifyGeometry( featGeometry, int( self.tolerance ), isPolygon ) newGeometry = densifyGeometry( featGeometry, int( self.tolerance ), isPolygon )
feature = QgsFeature() feature = QgsFeature()
feature.setGeometry( newGeometry ) feature.setGeometry( newGeometry )
feature.setAttributeMap( attrMap ) feature.setAttributes( attrMap )
shapeFileWriter.addFeature( feature ) shapeFileWriter.addFeature( feature )
featureId += 1 featureId += 1
self.emit( SIGNAL( "featureProcessed()" ) ) self.emit( SIGNAL( "featureProcessed()" ) )
@ -478,7 +477,8 @@ class GeomThread( QThread ):
vProvider = self.inputLayer.dataProvider() vProvider = self.inputLayer.dataProvider()
self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), vProvider.featureCount() ) self.emit( SIGNAL( "rangeCalculated( PyQt_PyObject )" ), vProvider.featureCount() )
f = QgsFeature() f = QgsFeature()
while vProvider.nextFeature( f ): fit = vProvider.getFeatures()
while fit.nextFeature( f ):
featureId = f.id() featureId = f.id()
featGeometry = QgsGeometry( f.geometry() ) featGeometry = QgsGeometry( f.geometry() )
newGeometry = densifyGeometry( featGeometry, int( self.tolerance ), isPolygon ) newGeometry = densifyGeometry( featGeometry, int( self.tolerance ), isPolygon )

20
python/plugins/fTools/tools/doSpatialJoin.py

@ -123,14 +123,11 @@ class Dialog(QDialog, Ui_Dialog):
def compute(self, inName, joinName, outName, summary, sumList, keep, progressBar): def compute(self, inName, joinName, outName, summary, sumList, keep, progressBar):
layer1 = ftools_utils.getVectorLayerByName(inName) layer1 = ftools_utils.getVectorLayerByName(inName)
provider1 = layer1.dataProvider() provider1 = layer1.dataProvider()
allAttrs = provider1.attributeIndexes()
provider1.select(allAttrs)
fieldList1 = ftools_utils.getFieldList(layer1).values() fieldList1 = ftools_utils.getFieldList(layer1).values()
layer2 = ftools_utils.getVectorLayerByName(joinName) layer2 = ftools_utils.getVectorLayerByName(joinName)
provider2 = layer2.dataProvider() provider2 = layer2.dataProvider()
allAttrs = provider2.attributeIndexes()
provider2.select(allAttrs)
fieldList2 = ftools_utils.getFieldList(layer2) fieldList2 = ftools_utils.getFieldList(layer2)
fieldList = [] fieldList = []
if provider1.crs() != provider2.crs(): if provider1.crs() != provider2.crs():
@ -180,11 +177,12 @@ class Dialog(QDialog, Ui_Dialog):
progressBar.setValue(15) progressBar.setValue(15)
start = 15.00 start = 15.00
add = 85.00 / provider1.featureCount() add = 85.00 / provider1.featureCount()
provider1.rewind()
index = ftools_utils.createIndex(provider2) index = ftools_utils.createIndex(provider2)
while provider1.nextFeature(inFeat): fit1 = provider1.getFeatures()
while fit1.nextFeature(inFeat):
inGeom = inFeat.geometry() inGeom = inFeat.geometry()
atMap1 = inFeat.attributeMap() atMap1 = inFeat.attributes()
outFeat.setGeometry(inGeom) outFeat.setGeometry(inGeom)
none = True none = True
joinList = [] joinList = []
@ -206,12 +204,12 @@ class Dialog(QDialog, Ui_Dialog):
count = 0 count = 0
for i in joinList: for i in joinList:
#tempGeom = i.geometry() #tempGeom = i.geometry()
provider2.featureAtId(int(i), inFeatB , True, allAttrs) provider2.getFeatures( QgsFeatureRequest().setFilterFid( int(i) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
if inGeom.intersects(tmpGeom): if inGeom.intersects(tmpGeom):
count = count + 1 count = count + 1
none = False none = False
atMap2 = inFeatB.attributeMap() atMap2 = inFeatB.attributes()
if not summary: if not summary:
atMap = atMap1.values() atMap = atMap1.values()
atMap2 = atMap2.values() atMap2 = atMap2.values()
@ -234,9 +232,9 @@ class Dialog(QDialog, Ui_Dialog):
atMap.append(QVariant(count)) atMap.append(QVariant(count))
atMap = dict(zip(seq, atMap)) atMap = dict(zip(seq, atMap))
if none: if none:
outFeat.setAttributeMap(atMap1) outFeat.setAttributes(atMap1)
else: else:
outFeat.setAttributeMap(atMap) outFeat.setAttributes(atMap)
if keep: # keep all records if keep: # keep all records
writer.addFeature(outFeat) writer.addFeature(outFeat)
else: # keep only matching records else: # keep only matching records

10
python/plugins/fTools/tools/doSubsetSelect.py

@ -83,9 +83,6 @@ class Dialog(QDialog, Ui_Dialog):
mlayer = ftools_utils.getMapLayerByName(inVect) mlayer = ftools_utils.getMapLayerByName(inVect)
mlayer.removeSelection(True) mlayer.removeSelection(True)
vlayer = ftools_utils.getVectorLayerByName(inVect) vlayer = ftools_utils.getVectorLayerByName(inVect)
vprovider = vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
vprovider.select(allAttrs)
index = vprovider.fieldNameIndex(inField) index = vprovider.fieldNameIndex(inField)
#unique = [] #unique = []
#vprovider.uniqueValues(index, unique) #vprovider.uniqueValues(index, unique)
@ -96,12 +93,13 @@ class Dialog(QDialog, Ui_Dialog):
nElement = 0 nElement = 0
self.progressBar.setValue(0) self.progressBar.setValue(0)
self.progressBar.setRange(0, nFeat) self.progressBar.setRange(0, nFeat)
fit = vprovider.getFeatures()
if not len(unique) == mlayer.featureCount(): if not len(unique) == mlayer.featureCount():
for i in unique: for i in unique:
vprovider.rewind() fit.rewind()
FIDs= [] FIDs= []
while vprovider.nextFeature(inFeat): while fit.nextFeature(inFeat):
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
if atMap[index] == QVariant(i): if atMap[index] == QVariant(i):
FID = inFeat.id() FID = inFeat.id()
FIDs.append(FID) FIDs.append(FID)

14
python/plugins/fTools/tools/doSumLines.py

@ -100,10 +100,6 @@ class Dialog(QDialog, Ui_Dialog):
lineProvider = lineLayer.dataProvider() lineProvider = lineLayer.dataProvider()
if polyProvider.crs() <> lineProvider.crs(): if polyProvider.crs() <> lineProvider.crs():
QMessageBox.warning(self, self.tr("CRS warning!"), self.tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results.")) QMessageBox.warning(self, self.tr("CRS warning!"), self.tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results."))
allAttrs = polyProvider.attributeIndexes()
polyProvider.select(allAttrs)
allAttrs = lineProvider.attributeIndexes()
lineProvider.select(allAttrs)
fieldList = ftools_utils.getFieldList(polyLayer) fieldList = ftools_utils.getFieldList(polyLayer)
index = polyProvider.fieldNameIndex(unicode(inField)) index = polyProvider.fieldNameIndex(unicode(inField))
if index == -1: if index == -1:
@ -117,7 +113,6 @@ class Dialog(QDialog, Ui_Dialog):
inGeom = QgsGeometry() inGeom = QgsGeometry()
outGeom = QgsGeometry() outGeom = QgsGeometry()
distArea = QgsDistanceArea() distArea = QgsDistanceArea()
lineProvider.rewind()
start = 15.00 start = 15.00
add = 85.00 / polyProvider.featureCount() add = 85.00 / polyProvider.featureCount()
check = QFile(self.shapefileName) check = QFile(self.shapefileName)
@ -127,9 +122,10 @@ class Dialog(QDialog, Ui_Dialog):
writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, polyProvider.geometryType(), sRs) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, polyProvider.geometryType(), sRs)
#writer = QgsVectorFileWriter(outPath, "UTF-8", fieldList, polyProvider.geometryType(), sRs) #writer = QgsVectorFileWriter(outPath, "UTF-8", fieldList, polyProvider.geometryType(), sRs)
spatialIndex = ftools_utils.createIndex( lineProvider ) spatialIndex = ftools_utils.createIndex( lineProvider )
while polyProvider.nextFeature(inFeat): polyFit = polyProvider.getFeatures()
while polyFit.nextFeature(inFeat):
inGeom = QgsGeometry(inFeat.geometry()) inGeom = QgsGeometry(inFeat.geometry())
atMap = inFeat.attributeMap() atMap = inFeat.attributes()
lineList = [] lineList = []
length = 0 length = 0
#(check, lineList) = lineLayer.featuresInRectangle(inGeom.boundingBox(), True, False) #(check, lineList) = lineLayer.featuresInRectangle(inGeom.boundingBox(), True, False)
@ -140,13 +136,13 @@ class Dialog(QDialog, Ui_Dialog):
else: check = 1 else: check = 1
if check == 0: if check == 0:
for i in lineList: for i in lineList:
lineProvider.featureAtId( int( i ), inFeatB , True, allAttrs ) lineProvider.getFeatures( QgsFeatureRequest().setFilterFid( int(i) ) ).nextFeature( inFeatB )
tmpGeom = QgsGeometry( inFeatB.geometry() ) tmpGeom = QgsGeometry( inFeatB.geometry() )
if inGeom.intersects(tmpGeom): if inGeom.intersects(tmpGeom):
outGeom = inGeom.intersection(tmpGeom) outGeom = inGeom.intersection(tmpGeom)
length = length + distArea.measure(outGeom) length = length + distArea.measure(outGeom)
outFeat.setGeometry(inGeom) outFeat.setGeometry(inGeom)
outFeat.setAttributeMap(atMap) outFeat.setAttributes(atMap)
outFeat.addAttribute(index, QVariant(length)) outFeat.addAttribute(index, QVariant(length))
writer.addFeature(outFeat) writer.addFeature(outFeat)
start = start + 1 start = start + 1

12
python/plugins/fTools/tools/doValidate.py

@ -182,7 +182,7 @@ class ValidateDialog( QDialog, Ui_Dialog ):
ft = QgsFeature() ft = QgsFeature()
(fid,ok) = self.tblUnique.item(row, 0).text().toInt() (fid,ok) = self.tblUnique.item(row, 0).text().toInt()
if not ok or not self.vlayer.featureAtId( fid, ft, True): if not ok or not self.vlayer.getFeatures( QgsFeatureRequest().setFilterFid( fid ) ).nextFeature( ft ):
return return
rect = mc.mapRenderer().layerExtentToOutputExtent( self.vlayer, ft.geometry().boundingBox() ) rect = mc.mapRenderer().layerExtentToOutputExtent( self.vlayer, ft.geometry().boundingBox() )
@ -298,7 +298,8 @@ class validateThread( QThread ):
layer = [] layer = []
vlayer.select([]) # select all features, and ignore attributes vlayer.select([]) # select all features, and ignore attributes
ft = QgsFeature() ft = QgsFeature()
while vlayer.nextFeature(ft): fit = vlayer.getFeatures()
while fit.nextFeature(ft):
layer.append(QgsFeature(ft)) layer.append(QgsFeature(ft))
nFeat = len(layer) nFeat = len(layer)
nElement = 0 nElement = 0
@ -317,8 +318,8 @@ class validateThread( QThread ):
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nFeat ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nFeat )
if self.writeShape: if self.writeShape:
fields = { 0 : QgsField( "FEAT_ID", QVariant.Int ), fields = [ QgsField( "FEAT_ID", QVariant.Int ),
1 : QgsField( "ERROR", QVariant.String ) } QgsField( "ERROR", QVariant.String ) ]
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields, writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBPoint, vlayer.crs() ) QGis.WKBPoint, vlayer.crs() )
for rec in lstErrors: for rec in lstErrors:
@ -335,8 +336,7 @@ class validateThread( QThread ):
geometry = QgsGeometry().fromPoint( myPoint ) geometry = QgsGeometry().fromPoint( myPoint )
ft = QgsFeature() ft = QgsFeature()
ft.setGeometry( geometry ) ft.setGeometry( geometry )
ft.setAttributeMap( { 0 : QVariant( fidItem ), ft.setAttributes( [ QVariant( fidItem ), QVariant( message ) ] )
1 : QVariant( message ) } )
writer.addFeature( ft ) writer.addFeature( ft )
del writer del writer
return "writeShape" return "writeShape"

12
python/plugins/fTools/tools/doVectorSplit.py

@ -162,8 +162,7 @@ class SplitThread(QThread):
index = provider.fieldNameIndex(self.field) index = provider.fieldNameIndex(self.field)
unique = ftools_utils.getUniqueValues(provider, int(index)) unique = ftools_utils.getUniqueValues(provider, int(index))
baseName = unicode( outPath + self.layer.name() + "_" + self.field + "_" ) baseName = unicode( outPath + self.layer.name() + "_" + self.field + "_" )
allAttrs = provider.attributeIndexes()
provider.select(allAttrs)
fieldList = ftools_utils.getFieldList(self.layer) fieldList = ftools_utils.getFieldList(self.layer)
sRs = provider.crs() sRs = provider.crs()
geom = self.layer.wkbType() geom = self.layer.wkbType()
@ -171,6 +170,8 @@ class SplitThread(QThread):
self.emit(SIGNAL("rangeCalculated(PyQt_PyObject)"), len(unique)) self.emit(SIGNAL("rangeCalculated(PyQt_PyObject)"), len(unique))
fit = provider.getFeatures()
for i in unique: for i in unique:
check = QFile(baseName + "_" + unicode(i.toString().trimmed()) + ".shp") check = QFile(baseName + "_" + unicode(i.toString().trimmed()) + ".shp")
fName = check.fileName() fName = check.fileName()
@ -180,9 +181,10 @@ class SplitThread(QThread):
continue continue
writer = QgsVectorFileWriter(fName, self.encoding, fieldList, geom, sRs) writer = QgsVectorFileWriter(fName, self.encoding, fieldList, geom, sRs)
provider.rewind()
while provider.nextFeature(inFeat): fit.rewind()
atMap = inFeat.attributeMap() while fit.nextFeature(inFeat):
atMap = inFeat.attributes()
if atMap[index] == i: if atMap[index] == i:
writer.addFeature(inFeat) writer.addFeature(inFeat)
del writer del writer

33
python/plugins/fTools/tools/doVisual.py

@ -236,9 +236,6 @@ class visualThread( QThread ):
def list_unique_values( self, vlayer, myField ): def list_unique_values( self, vlayer, myField ):
vprovider = vlayer.dataProvider() vprovider = vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
fields = vprovider.fields()
index = vprovider.fieldNameIndex( myField ) index = vprovider.fieldNameIndex( myField )
unique = ftools_utils.getUniqueValues( vprovider, int( index ) ) unique = ftools_utils.getUniqueValues( vprovider, int( index ) )
lstUnique = [] lstUnique = []
@ -256,9 +253,6 @@ class visualThread( QThread ):
def basic_statistics( self, vlayer, myField ): def basic_statistics( self, vlayer, myField ):
vprovider = vlayer.dataProvider() vprovider = vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
fields = vprovider.fields()
index = vprovider.fieldNameIndex( myField ) index = vprovider.fieldNameIndex( myField )
feat = QgsFeature() feat = QgsFeature()
sumVal = 0.0 sumVal = 0.0
@ -279,7 +273,7 @@ class visualThread( QThread ):
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
for f in selection: for f in selection:
atMap = f.attributeMap() atMap = f.attributes()
lenVal = float( len( atMap[ index ].toString() ) ) lenVal = float( len( atMap[ index ].toString() ) )
if first: if first:
minVal = lenVal minVal = lenVal
@ -301,9 +295,9 @@ class visualThread( QThread ):
if nFeat > 0: if nFeat > 0:
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
vprovider.select( allAttrs ) fit = vprovider.getFeatures()
while vprovider.nextFeature( feat ): while fit.nextFeature( feat ):
atMap = feat.attributeMap() atMap = feat.attributes()
lenVal = float( len( atMap[ index ].toString() ) ) lenVal = float( len( atMap[ index ].toString() ) )
if first: if first:
minVal = lenVal minVal = lenVal
@ -348,7 +342,7 @@ class visualThread( QThread ):
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
for f in selection: for f in selection:
atMap = f.attributeMap() atMap = f.attributes()
value = float( atMap[ index ].toDouble()[ 0 ] ) value = float( atMap[ index ].toDouble()[ 0 ] )
if first: if first:
minVal = value minVal = value
@ -367,9 +361,9 @@ class visualThread( QThread ):
if nFeat > 0: if nFeat > 0:
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
vprovider.select( allAttrs ) fit = vprovider.getFeatures()
while vprovider.nextFeature( feat ): while fit.nextFeature( feat ):
atMap = feat.attributeMap() atMap = feat.attributes()
value = float( atMap[ index ].toDouble()[ 0 ] ) value = float( atMap[ index ].toDouble()[ 0 ] )
if first: if first:
minVal = value minVal = value
@ -415,10 +409,6 @@ class visualThread( QThread ):
def nearest_neighbour_analysis( self, vlayer ): def nearest_neighbour_analysis( self, vlayer ):
vprovider = vlayer.dataProvider() vprovider = vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
feat = QgsFeature()
neighbour = QgsFeature()
sumDist = 0.00 sumDist = 0.00
distance = QgsDistanceArea() distance = QgsDistanceArea()
A = vlayer.extent() A = vlayer.extent()
@ -430,9 +420,12 @@ class visualThread( QThread ):
if nFeat > 0: if nFeat > 0:
self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 ) self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) ) self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
while vprovider.nextFeature( feat ): feat = QgsFeature()
neighbour = QgsFeature()
fit = vprovider.getFeatures()
while fit.nextFeature( feat ):
neighbourID = index.nearestNeighbor( feat.geometry().asPoint(), 2 )[ 1 ] neighbourID = index.nearestNeighbor( feat.geometry().asPoint(), 2 )[ 1 ]
vprovider.featureAtId( neighbourID, neighbour, True, [] ) vprovider.getFeatures( QgsFeatureRequest().setFilterFid( neighbourID ).setSubsetOfAttributes( [] ) ).nextFeature( neighbour )
nearDist = distance.measureLine( neighbour.geometry().asPoint(), feat.geometry().asPoint() ) nearDist = distance.measureLine( neighbour.geometry().asPoint(), feat.geometry().asPoint() )
sumDist += nearDist sumDist += nearDist
nElement += 1 nElement += 1

50
python/plugins/fTools/tools/ftools_utils.py

@ -32,7 +32,6 @@
# Utility functions # Utility functions
# ------------------------------------------------- # -------------------------------------------------
# #
# combineVectorAttributes( QgsAttributeMap, QgsAttributeMap )
# convertFieldNameType( QgsField.name() ) # convertFieldNameType( QgsField.name() )
# combineVectorFields( QgsVectorLayer, QgsVectorLayer ) # combineVectorFields( QgsVectorLayer, QgsVectorLayer )
# checkCRSCompatibility( QgsCoordinateReferenceSystem, QgsCoordinateReferenceSystem ) # checkCRSCompatibility( QgsCoordinateReferenceSystem, QgsCoordinateReferenceSystem )
@ -63,15 +62,6 @@ from qgis.gui import *
import locale import locale
# From two input attribute maps, create single attribute map
def combineVectorAttributes( atMapA, atMapB ):
attribA = atMapA.values()
lengthA = len(attribA)
attribB = atMapB.values()
lengthB = len(attribB)
attribA.extend( attribB )
return dict( zip( range( 0, lengthB + lengthA ), attribA ) )
# For use with memory provider/layer, converts full field type to simple string # For use with memory provider/layer, converts full field type to simple string
def convertFieldNameType( inName ): def convertFieldNameType( inName ):
if inName == "Integer": if inName == "Integer":
@ -83,12 +73,10 @@ def convertFieldNameType( inName ):
# From two input field maps, create single field map # From two input field maps, create single field map
def combineVectorFields( layerA, layerB ): def combineVectorFields( layerA, layerB ):
fieldsA = layerA.dataProvider().fields().values() fieldsA = layerA.dataProvider().fields()
fieldsB = layerB.dataProvider().fields().values() fieldsB = layerB.dataProvider().fields()
fieldsB = testForUniqueness( fieldsA, fieldsB ) fieldsB = testForUniqueness( fieldsA, fieldsB )
seq = range( 0, len( fieldsA ) + len( fieldsB ) )
fieldsA.extend( fieldsB ) fieldsA.extend( fieldsB )
fieldsA = dict( zip ( seq, fieldsA ) )
return fieldsA return fieldsA
# Check if two input CRSs are identical # Check if two input CRSs are identical
@ -258,20 +246,14 @@ def getMapLayerByName( myName ):
# Return the field list of a vector layer # Return the field list of a vector layer
def getFieldList( vlayer ): def getFieldList( vlayer ):
vprovider = vlayer.dataProvider() return vlayer.dataProvider().fields()
feat = QgsFeature()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
myFields = vprovider.fields()
return myFields
# Convinience function to create a spatial index for input QgsVectorDataProvider # Convinience function to create a spatial index for input QgsVectorDataProvider
def createIndex( provider ): def createIndex( provider ):
feat = QgsFeature() feat = QgsFeature()
index = QgsSpatialIndex() index = QgsSpatialIndex()
provider.rewind() fit = provider.getFeatures()
provider.select() while fit.nextFeature( feat ):
while provider.nextFeature( feat ):
index.insertFeature( feat ) index.insertFeature( feat )
return index return index
@ -292,8 +274,7 @@ def addShapeToCanvas( shapefile_path ):
# Return all unique values in field based on field index # Return all unique values in field based on field index
def getUniqueValues( provider, index ): def getUniqueValues( provider, index ):
values = provider.uniqueValues( index ) return provider.uniqueValues( index )
return values
# Generate a save file dialog with a dropdown box for choosing encoding style # Generate a save file dialog with a dropdown box for choosing encoding style
def saveDialog( parent, filtering="Shapefiles (*.shp *.SHP)"): def saveDialog( parent, filtering="Shapefiles (*.shp *.SHP)"):
@ -348,29 +329,28 @@ def dirDialog( parent ):
# Return field type from it's name # Return field type from it's name
def getFieldType(vlayer, fieldName): def getFieldType(vlayer, fieldName):
fields = vlayer.dataProvider().fields() for field in vlayer.dataProvider().fields():
for name, field in fields.iteritems():
if field.name() == fieldName: if field.name() == fieldName:
return field.typeName() return field.typeName()
# return the number of unique values in field # return the number of unique values in field
def getUniqueValuesCount( vlayer, fieldIndex, useSelection ): def getUniqueValuesCount( vlayer, fieldIndex, useSelection ):
vprovider = vlayer.dataProvider()
allAttrs = vprovider.attributeIndexes()
vprovider.select( allAttrs )
count = 0 count = 0
values = [] values = []
if useSelection: if useSelection:
selection = vlayer.selectedFeatures() selection = vlayer.selectedFeatures()
for f in selection: for f in selection:
if f.attributeMap()[ fieldIndex ].toString() not in values: v = f.attributes()[ fieldIndex ].toString()
values.append( f.attributeMap()[ fieldIndex ].toString() ) if v not in values:
values.append( v )
count += 1 count += 1
else: else:
feat = QgsFeature() feat = QgsFeature()
while vprovider.nextFeature( feat ): fit = vlayer.dataProvider().getFeatures()
if feat.attributeMap()[ fieldIndex ].toString() not in values: while fit.nextFeature( feat ):
values.append( feat.attributeMap()[ fieldIndex ].toString() ) v = feat.attributes()[ fieldIndex ].toString()
if v not in values:
values.append( v )
count += 1 count += 1
return count return count