[QGIS Commit] r10306 - in branches/analysis_branch/src/analysis: .
vector
svn_qgis at osgeo.org
svn_qgis at osgeo.org
Thu Mar 19 14:06:24 EDT 2009
Author: timlinux
Date: 2009-03-19 14:06:24 -0400 (Thu, 19 Mar 2009)
New Revision: 10306
Added:
branches/analysis_branch/src/analysis/vector/
branches/analysis_branch/src/analysis/vector/qgsgeometryanalyzer.cpp
branches/analysis_branch/src/analysis/vector/qgsgeometryanalyzer.h
Log:
Stubs for geometry analyzer class
Added: branches/analysis_branch/src/analysis/vector/qgsgeometryanalyzer.cpp
===================================================================
--- branches/analysis_branch/src/analysis/vector/qgsgeometryanalyzer.cpp (rev 0)
+++ branches/analysis_branch/src/analysis/vector/qgsgeometryanalyzer.cpp 2009-03-19 18:06:24 UTC (rev 10306)
@@ -0,0 +1,724 @@
+bool QgsGeometryAnalyzer::single_to_multi( self )
+{
+/* vprovider = self.vlayer.dataProvider()
+ allAttrs = vprovider.attributeIndexes()
+ vprovider.select( allAttrs )
+ fields = vprovider.fields()
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, vprovider.geometryType(), vprovider.crs() )
+ inFeat = QgsFeature()
+ outFeat = QgsFeature()
+ inGeom = QgsGeometry()
+ outGeom = QgsGeometry()
+ index = vprovider.fieldNameIndex( self.myField )
+ if not index == -1:
+ unique = ftools_utils.getUniqueValues( vprovider, int( index ) )
+ else:
+ unique = range( 0, self.vlayer.featureCount() )
+ nFeat = vprovider.featureCount() * len( unique )
+ nElement = 0
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
+ if not len( unique ) == self.vlayer.featureCount()
+ for i in unique:
+ vprovider.rewind()
+ multi_feature= []
+ first = True
+ while vprovider.nextFeature( inFeat )
+ atMap = inFeat.attributeMap()
+ idVar = atMap[ index ]
+ if idVar.toString().trimmed() == i.toString().trimmed()
+ if first:
+ atts = atMap
+ first = False
+ inGeom = QgsGeometry( inFeat.geometry() )
+ vType = inGeom.type()
+ feature_list = self.extractAsMulti( inGeom )
+ multi_feature.extend( feature_list )
+ nElement += 1
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
+ outFeat.setAttributeMap( atts )
+ outGeom = QgsGeometry( self.convertGeometry( multi_feature, vType ) )
+ outFeat.setGeometry( outGeom )
+ writer.addFeature( outFeat )
+ del writer
+ return True
+
+ */
+}
+bool QgsGeometryAnalyzer::multi_to_single( self )
+{
+ /*
+ vprovider = self.vlayer.dataProvider()
+ allAttrs = vprovider.attributeIndexes()
+ vprovider.select( allAttrs )
+ fields = vprovider.fields()
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, vprovider.geometryType(), vprovider.crs() )
+ inFeat = QgsFeature()
+ outFeat = QgsFeature()
+ inGeom = QgsGeometry()
+ outGeom = QgsGeometry()
+ nFeat = vprovider.featureCount()
+ nElement = 0
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
+ while vprovider.nextFeature( inFeat )
+ nElement += 1
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
+ inGeom = inFeat.geometry()
+ atMap = inFeat.attributeMap()
+ featList = self.extractAsSingle( inGeom )
+ outFeat.setAttributeMap( atMap )
+ for i in featList:
+ outFeat.setGeometry( i )
+ writer.addFeature( outFeat )
+ del writer
+ return True
+
+ */
+}
+bool QgsGeometryAnalyzer::extract_nodes( self )
+{
+ /*
+ vprovider = self.vlayer.dataProvider()
+ allAttrs = vprovider.attributeIndexes()
+ vprovider.select( allAttrs )
+ fields = vprovider.fields()
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, QGis.WKBPoint, vprovider.crs() )
+ inFeat = QgsFeature()
+ outFeat = QgsFeature()
+ inGeom = QgsGeometry()
+ outGeom = QgsGeometry()
+ nFeat = vprovider.featureCount()
+ nElement = 0
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
+ while vprovider.nextFeature( inFeat )
+ nElement += 1
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
+ inGeom = inFeat.geometry()
+ atMap = inFeat.attributeMap()
+ pointList = ftools_utils.extractPoints( inGeom )
+ outFeat.setAttributeMap( atMap )
+ for i in pointList:
+ outFeat.setGeometry( outGeom.fromPoint( i ) )
+ writer.addFeature( outFeat )
+ del writer
+ return True
+
+ */
+}
+bool QgsGeometryAnalyzer::polygons_to_lines( self )
+{
+ /*
+ vprovider = self.vlayer.dataProvider()
+ allAttrs = vprovider.attributeIndexes()
+ vprovider.select( allAttrs )
+ fields = vprovider.fields()
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, QGis.WKBLineString, vprovider.crs() )
+ inFeat = QgsFeature()
+ outFeat = QgsFeature()
+ inGeom = QgsGeometry()
+ outGeom = QgsGeometry()
+ nFeat = vprovider.featureCount()
+ nElement = 0
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0)
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
+ while vprovider.nextFeature(inFeat)
+ multi = False
+ nElement += 1
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
+ inGeom = inFeat.geometry()
+ if inGeom.isMultipart()
+ multi = True
+ atMap = inFeat.attributeMap()
+ lineList = self.extractAsLine( inGeom )
+ outFeat.setAttributeMap( atMap )
+ for h in lineList:
+ outFeat.setGeometry( outGeom.fromPolyline( h ) )
+ writer.addFeature( outFeat )
+ del writer
+ return True
+
+ */
+}
+bool QgsGeometryAnalyzer::export_geometry_info( self )
+{
+ /*
+ vprovider = self.vlayer.dataProvider()
+ allAttrs = vprovider.attributeIndexes()
+ vprovider.select( allAttrs )
+ ( fields, index1, index2 ) = self.checkGeometryFields( self.vlayer )
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, vprovider.geometryType(), vprovider.crs() )
+ inFeat = QgsFeature()
+ outFeat = QgsFeature()
+ inGeom = QgsGeometry()
+ nFeat = vprovider.featureCount()
+ nElement = 0
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0)
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
+ while vprovider.nextFeature(inFeat)
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
+ nElement += 1
+ inGeom = inFeat.geometry()
+ ( attr1, attr2 ) = self.simpleMeasure( inGeom )
+ outFeat.setGeometry( inGeom )
+ atMap = inFeat.attributeMap()
+ outFeat.setAttributeMap( atMap )
+ outFeat.addAttribute( index1, QVariant( attr1 ) )
+ outFeat.addAttribute( index2, QVariant( attr2 ) )
+ writer.addFeature( outFeat )
+ del writer
+ return True
+
+ */
+}
+bool QgsGeometryAnalyzer::simplify_geometry( self )
+{
+ /*
+ vprovider = self.vlayer.dataProvider()
+ tolerance = self.myParam
+ allAttrs = vprovider.attributeIndexes()
+ vprovider.select( allAttrs )
+ fields = vprovider.fields()
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, vprovider.geometryType(), vprovider.crs() )
+ inFeat = QgsFeature()
+ outFeat = QgsFeature()
+ nFeat = vprovider.featureCount()
+ nElement = 0
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
+ self.measure = QgsDistanceArea()
+ while vprovider.nextFeature( inFeat )
+ nElement += 1
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
+ inGeom = inFeat.geometry()
+ atMap = inFeat.attributeMap()
+ outGeom = self.extractAsSimple( inGeom, tolerance )
+ if outGeom is None:
+ return "math_error"
+ outFeat.setAttributeMap( atMap )
+ outFeat.setGeometry( outGeom )
+ writer.addFeature( outFeat )
+ del writer
+ return True
+
+ */
+}
+bool QgsGeometryAnalyzer::polygon_centroids( self )
+{
+ /*
+ vprovider = self.vlayer.dataProvider()
+ allAttrs = vprovider.attributeIndexes()
+ vprovider.select( allAttrs )
+ fields = vprovider.fields()
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, QGis.WKBPoint, vprovider.crs() )
+ inFeat = QgsFeature()
+ outfeat = QgsFeature()
+ nFeat = vprovider.featureCount()
+ nElement = 0
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
+ while vprovider.nextFeature( inFeat )
+ geom = inFeat.geometry()
+ area = QgsDistanceArea()
+ A = area.measure( geom )
+ multi_geom = QgsGeometry()
+ bounding = inFeat.geometry().boundingBox()
+ xmin = bounding.xMinimum()
+ ymin = bounding.yMinimum()
+ xmax = bounding.xMaximum()
+ ymax = bounding.yMaximum()
+ if geom.type() == 2:
+ cx = 0
+ cy = 0
+ area2 = 0
+ if geom.isMultipart()
+ multi_geom = geom.asMultiPolygon()
+ for k in multi_geom:
+ for h in k:
+ for i in range(0, len(h) - 1)
+ j = (i + 1) % len(h)
+ factor = ((h[i].x()) * (h[j].y()) - (h[j].x()) * (h[i].y()))
+ cx = cx + ((h[i].x()) + (h[j].x())) * factor
+ cy = cy + ((h[i].y()) + (h[j].y())) * factor
+ else:
+ multi_geom = geom.asPolygon()
+ for k in multi_geom:
+ for i in range(0, len(k) - 1)
+ j = (i + 1) % len(k)
+ factor = (k[i].x()) * (k[j].y()) - (k[j].x()) * (k[i].y())
+ cx = cx + ((k[i].x()) + (k[j].x())) * factor
+ cy = cy + ((k[i].y()) + (k[j].y())) * factor
+ A = A * 6
+ factor = 1/A
+ cx = cx * factor
+ cy = cy * factor
+ if cx < xmin:
+ cx = cx * -1
+ if cy < ymin:
+ cy = cy * -1
+ if cx > xmax:
+ cx = cx * -1
+ if cy > ymax:
+ cy = cy * -1
+ outfeat.setGeometry( QgsGeometry.fromPoint( QgsPoint( cx, cy ) ) )
+ atMap = inFeat.attributeMap()
+ outfeat.setAttributeMap( atMap )
+ writer.addFeature( outfeat )
+ nElement += 1
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
+ del writer
+ return True
+
+ */
+}
+bool QgsGeometryAnalyzer::delaunay_triangulation( self )
+{
+ /*
+ import voronoi
+ vprovider = self.vlayer.dataProvider()
+ allAttrs = vprovider.attributeIndexes()
+ vprovider.select( allAttrs )
+ fields = {
+ 0 : QgsField( "POINTA", QVariant.Double ),
+ 1 : QgsField( "POINTB", QVariant.Double ),
+ 2 : QgsField( "POINTC", QVariant.Double ) }
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, QGis.WKBPolygon, vprovider.crs() )
+ inFeat = QgsFeature()
+ points = []
+ print "here"
+ while vprovider.nextFeature( inFeat )
+ inGeom = QgsGeometry( inFeat.geometry() )
+ point = inGeom.asPoint()
+ points.append( point )
+ print "or here"
+ vprovider.rewind()
+ vprovider.select( allAttrs )
+ triangles = voronoi.computeDelaunayTriangulation( points )
+ feat = QgsFeature()
+ nFeat = len( triangles )
+ nElement = 0
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, nFeat ) )
+ for triangle in triangles:
+ indicies = list( triangle )
+ indicies.append( indicies[ 0 ] )
+ polygon = []
+ step = 0
+ for index in indicies:
+ vprovider.featureAtId( index, feat, True, allAttrs )
+ geom = QgsGeometry( feat.geometry() )
+ point = QgsPoint( geom.asPoint() )
+ polygon.append( point )
+ feat.addAttribute( step, QVariant( index ) )
+ step += 1
+ geometry = QgsGeometry().fromPolygon( [ polygon ] )
+ feat.setGeometry( geometry )
+ writer.addFeature( feat )
+ nElement += 1
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), nElement )
+ del writer
+ return True
+
+ */
+}
+bool QgsGeometryAnalyzer::layer_extent( self )
+{
+ /*
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, 0 ) )
+ fields = {
+ 0 : QgsField( "MINX", QVariant.Double ),
+ 1 : QgsField( "MINY", QVariant.Double ),
+ 2 : QgsField( "MAXX", QVariant.Double ),
+ 3 : QgsField( "MAXY", QVariant.Double ),
+ 4 : QgsField( "CNTX", QVariant.Double ),
+ 5 : QgsField( "CNTY", QVariant.Double ),
+ 6 : QgsField( "AREA", QVariant.Double ),
+ 7 : QgsField( "PERIM", QVariant.Double ),
+ 8 : QgsField( "HEIGHT", QVariant.Double ),
+ 9 : QgsField( "WIDTH", QVariant.Double ) }
+
+ writer = QgsVectorFileWriter( self.myName, self.myEncoding,
+ fields, QGis.WKBPolygon, self.vlayer.srs() )
+ rect = self.vlayer.extent()
+ minx = rect.xMinimum()
+ miny = rect.yMinimum()
+ maxx = rect.xMaximum()
+ maxy = rect.yMaximum()
+ height = rect.height()
+ width = rect.width()
+ cntx = minx + ( width / 2.0 )
+ cnty = miny + ( height / 2.0 )
+ area = width * height
+ perim = ( 2 * width ) + (2 * height )
+ rect = [
+ QgsPoint( minx, miny ),
+ QgsPoint( minx, maxy ),
+ QgsPoint( maxx, maxy ),
+ QgsPoint( maxx, miny ),
+ QgsPoint( minx, miny ) ]
+ geometry = QgsGeometry().fromPolygon( [ rect ] )
+ feat = QgsFeature()
+ feat.setGeometry( geometry )
+ feat.setAttributeMap( {
+ 0 : QVariant( minx ),
+ 1 : QVariant( miny ),
+ 2 : QVariant( maxx ),
+ 3 : QVariant( maxy ),
+ 4 : QVariant( cntx ),
+ 5 : QVariant( cnty ),
+ 6 : QVariant( area ),
+ 7 : QVariant( perim ),
+ 8 : QVariant( height ),
+ 9 : QVariant( width ) } )
+ writer.addFeature( feat )
+ self.emit( SIGNAL( "runRange(PyQt_PyObject)" ), ( 0, 100 ) )
+ self.emit( SIGNAL( "runStatus(PyQt_PyObject)" ), 0 )
+ del writer
+
+ return True
+*/
+
+}
+bool QgsGeometryAnalyzer::extractAsSimple( self, geom, tolerance )
+{
+ /*
+ temp_geom1 = []
+ temp_geom2 = []
+ if geom.type() == 1:
+ if geom.isMultipart()
+ multi_geom = geom.asMultiPolyline()
+ for i in multi_geom:
+ simple = self.simlifyLine( i, 1, tolerance )
+ if simple is None:
+ return None
+ else:
+ temp_geom1.append( simple )
+ return QgsGeometry().fromMultiPolyline(temp_geom1)
+ else:
+ multi_geom = self.simplifyLine( geom.asPolyline(), 1, tolerance )
+ if multi_geom is None:
+ return None
+ else:
+ return QgsGeometry().fromPolyline(multi_geom)
+ elif geom.type() == 2:
+ if geom.isMultipart()
+ multi_geom = geom.asMultiPolygon()
+ for i in multi_geom:
+ temp_geom2 = []
+ for j in i:
+ simple = self.simplifyLine( j, 2, tolerance )
+ if simple is None:
+ return None
+ else:
+ temp_geom2.append( simple )
+ temp_geom1.append( temp_geom2 )
+ return QgsGeometry().fromMultiPolygon( temp_geom1 )
+ else:
+ multi_geom = geom.asPolygon()
+ for i in multi_geom:
+ simple = self.simplifyLine( i, 2, tolerance )
+ if simple is None:
+ return None
+ else:
+ temp_geom1.append( simple )
+ return QgsGeometry().fromPolygon(temp_geom1)
+
+ */
+}
+bool QgsGeometryAnalyzer::simplifyLine( self, ln, typ, tol )
+{
+ /*
+ newline = []
+ last = len(ln) - 1
+ if typ == 2:
+ tml = 0.00
+ mid = 1
+ for m in range(1 , last)
+ ml = self.measure.measureLine(ln[0], ln[m])
+ if ml > tml:
+ tml = ml
+ mid = m
+ keep = [0, mid, last]
+ try:
+ keep.extend( self.recursiveDouglasPeucker( ln, tol, 0, mid) )
+ keep.extend( self.recursiveDouglasPeucker( ln, tol, mid, last) )
+ except:
+ return None
+ if len(keep) <= 3:
+ return ln
+ else:
+ keep = [0, last]
+ keep.extend( self.recursiveDouglasPeucker( ln, tol, 0, last) )
+ keep.sort()
+ for i in keep:
+ newline.append(ln[i])
+ return newline
+
+ */
+}
+bool QgsGeometryAnalyzer::recursiveDouglasPeucker( self, line, tol, j, k )
+{
+ /*
+ # recursiveDouglasPeucker based on function
+ # by Schuyler Erle <schuyler at nocat.net>
+ # Copyright (c) 2005, Frank Warmerdam <warmerdam at pobox.com>
+ keep = []
+ if k <= j+1: # there is nothing to simplify
+ return keep
+ # degenerate case
+ if self.measure.measureLine( line[ j ], line[ k ]) < tol:
+ return keep
+ # check for adequate approximation by segment S from v[j] to v[k]
+ maxi = j # index of vertex farthest from S
+ maxd = 0 # distance squared of farthest vertex
+ tline = [ line[ j ], line[ k ] ]
+ # test each vertex v[i] for max distance from S
+ for i in range( j + 1, k )
+ # compute distance
+ #dv = seg.Distance( pts[i] )
+ dv = self.shortestDistance( tline, line[ i ] )
+ if dv is None:
+ return None
+ # test with current max distance
+ if dv > maxd:
+ # v[i] is a new max vertex
+ maxi = i
+ maxd = dv
+ if maxd > tol: # error is worse than the tolerance
+ # split the polyline at the farthest vertex from S
+ keep.append( maxi ) # mark v[maxi] for the simplified polyline
+ # recursively simplify the two subpolylines at v[maxi]
+ keep.extend( self.recursiveDouglasPeucker( line, tol, j, maxi ) ) # v[j] to v[maxi]
+ keep.extend( self.recursiveDouglasPeucker( line, tol, maxi, k ) ) # v[maxi] to v[k]
+
+ # else the approximation is OK, so ignore intermediate vertices
+ return keep
+*/
+
+}
+bool QgsGeometryAnalyzer::shortestDistance( self, tline, point)
+{
+ /*
+ try:
+ a = self.measure.measureLine( tline[ 1 ], point )
+ b = self.measure.measureLine( tline[ 0 ], point)
+ c = self.measure.measureLine( tline[ 0 ], tline[ 1 ] )
+ if a * b * c == 0.00:
+ return 0.00
+ x = ( ( a * a + b * b - c * c ) / ( 2.00 * b ) )
+ h = math.sqrt( ( a * a ) - ( x * x ) )
+ y = ( b - x )
+ a3 = ( math.atan( h / x ) )
+ if a3 < 0:
+ a3 = a3 + math.pi
+ elif a3 > math.pi:
+ a3 = a3 - math.pi
+ a1 = ( math.atan( h / y ) )
+ if a1 < 0:
+ a1 = a1 + math.pi
+ elif a1 > math.pi:
+ a1 = a1 - math.pi
+ a3 = a3 * ( 180 / math.pi )
+ a1 = a1 * (180 / math.pi)
+ a2 = ( ( math.pi ) * ( 180 / math.pi ) ) - a1 - a3
+ if a3 >= 90.00:
+ length = c
+ elif a2 >= 90.00:
+ length = b
+ length = math.sin( a1 ) * b
+ return math.fabs( length )
+ except:
+ return None
+
+ */
+}
+bool QgsGeometryAnalyzer::simpleMeasure( self, inGeom )
+{
+ /*
+ if inGeom.wkbType() == QGis.WKBPoint:
+ pt = QgsPoint()
+ pt = inGeom.asPoint()
+ attr1 = pt.x()
+ attr2 = pt.y()
+ else:
+ measure = QgsDistanceArea()
+ attr1 = measure.measure(inGeom)
+ if inGeom.type() == QGis.Polygon:
+ attr2 = self.perimMeasure( inGeom, measure )
+ else:
+ attr2 = attr1
+ return ( attr1, attr2 )
+
+ */
+}
+bool QgsGeometryAnalyzer::perimMeasure( self, inGeom, measure )
+{
+ /*
+ value = 0.00
+ if inGeom.isMultipart()
+ poly = inGeom.asMultiPolygon()
+ for k in poly:
+ for j in k:
+ value = value + measure.measureLine( j )
+ else:
+ poly = inGeom.asPolygon()
+ for k in poly:
+ value = value + measure.measureLine( k )
+ return value
+*/
+
+}
+bool QgsGeometryAnalyzer::checkForField( self, L, e )
+{
+ /*
+ e = QString( e ).toLower()
+ fieldRange = range( 0,len( L ) )
+ for item in fieldRange:
+ if L[ item ].toLower() == e:
+ return True, item
+ return False, len( L )
+*/
+
+}
+bool QgsGeometryAnalyzer::checkGeometryFields( self, vlayer )
+{
+ /*
+ vprovider = vlayer.dataProvider()
+ nameList = []
+ fieldList = vprovider.fields()
+ geomType = vlayer.geometryType()
+ for i in fieldList.keys()
+ nameList.append( fieldList[ i ].name().toLower() )
+ if geomType == QGis.Polygon:
+ plp = "Poly"
+ ( found, index1 ) = self.checkForField( nameList, "AREA" )
+ if not found:
+ field = QgsField( "AREA", QVariant.Double, "double", 10, 6, "Polygon area" )
+ index1 = len( fieldList.keys() )
+ fieldList[ index1 ] = field
+ ( found, index2 ) = self.checkForField( nameList, "PERIMETER" )
+
+ if not found:
+ field = QgsField( "PERIMETER", QVariant.Double, "double", 10, 6, "Polygon perimeter" )
+ index2 = len( fieldList.keys() )
+ fieldList[ index2 ] = field
+ elif geomType == QGis.Line:
+ plp = "Line"
+ (found, index1) = self.checkForField(nameList, "LENGTH")
+ if not found:
+ field = QgsField("LENGTH", QVariant.Double, "double", 10, 6, "Line length")
+ index1 = len(fieldList.keys())
+ fieldList[index1] = field
+ index2 = index1
+ else:
+ plp = "Point"
+ (found, index1) = self.checkForField(nameList, "XCOORD")
+ if not found:
+ field = QgsField("XCOORD", QVariant.Double, "double", 10, 6, "Point x coordinate")
+ index1 = len(fieldList.keys())
+ fieldList[index1] = field
+ (found, index2) = self.checkForField(nameList, "YCOORD")
+ if not found:
+ field = QgsField("YCOORD", QVariant.Double, "double", 10, 6, "Point y coordinate")
+ index2 = len(fieldList.keys())
+ fieldList[index2] = field
+ return (fieldList, index1, index2)
+
+*/
+
+}
+bool QgsGeometryAnalyzer::extractAsLine( self, geom )
+{
+ /*
+ multi_geom = QgsGeometry()
+ temp_geom = []
+ if geom.type() == 2:
+ if geom.isMultipart()
+ multi_geom = geom.asMultiPolygon()
+ for i in multi_geom:
+ temp_geom.extend(i)
+ else:
+ multi_geom = geom.asPolygon()
+ temp_geom = multi_geom
+ return temp_geom
+ else:
+ return []
+
+
+*/
+}
+bool QgsGeometryAnalyzer::extractAsSingle( self, geom )
+{
+ /*
+ multi_geom = QgsGeometry()
+ temp_geom = []
+ if geom.type() == 0:
+ if geom.isMultipart()
+ multi_geom = geom.asMultiPoint()
+ for i in multi_geom:
+ temp_geom.append( QgsGeometry().fromPoint ( i ) )
+ else:
+ temp_geom.append( geom )
+ elif geom.type() == 1:
+ if geom.isMultipart()
+ multi_geom = geom.asMultiPolyline()
+ for i in multi_geom:
+ temp_geom.append( QgsGeometry().fromPolyline( i ) )
+ else:
+ temp_geom.append( geom )
+ elif geom.type() == 2:
+ if geom.isMultipart()
+ multi_geom = geom.asMultiPolygon()
+ for i in multi_geom:
+ temp_geom.append( QgsGeometry().fromPolygon( i ) )
+ else:
+ temp_geom.append( geom )
+ return temp_geom
+
+*/
+
+}
+bool QgsGeometryAnalyzer::extractAsMulti( self, geom )
+{
+ /*
+ temp_geom = []
+ if geom.type() == 0:
+ if geom.isMultipart()
+ return geom.asMultiPoint()
+ else:
+ return [ geom.asPoint() ]
+ elif geom.type() == 1:
+ if geom.isMultipart()
+ return geom.asMultiPolyline()
+ else:
+ return [ geom.asPolyline() ]
+ else:
+ if geom.isMultipart()
+ return geom.asMultiPolygon()
+ else:
+ return [ geom.asPolygon() ]
+
+*/
+
+}
+bool QgsGeometryAnalyzer::convertGeometry( self, geom_list, vType )
+{
+ /*
+ if vType == 0:
+ return QgsGeometry().fromMultiPoint(geom_list)
+ elif vType == 1:
+ return QgsGeometry().fromMultiPolyline(geom_list)
+ else:
+ return QgsGeometry().fromMultiPolygon(geom_list)
+ */
+}
Added: branches/analysis_branch/src/analysis/vector/qgsgeometryanalyzer.h
===================================================================
--- branches/analysis_branch/src/analysis/vector/qgsgeometryanalyzer.h (rev 0)
+++ branches/analysis_branch/src/analysis/vector/qgsgeometryanalyzer.h 2009-03-19 18:06:24 UTC (rev 10306)
@@ -0,0 +1,51 @@
+/***************************************************************************
+ qgsgeometryanalyzer.h - QGIS Tools for vector geometry analysis
+ -------------------
+ begin : 19 March 2009
+ copyright : (C) Carson Farmer
+ email : carson.farmer at gmail.com
+ ***************************************************************************/
+
+/***************************************************************************
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ ***************************************************************************/
+/* $Id: qgis.h 9774 2008-12-12 05:41:24Z timlinux $ */
+
+#ifndef QGSGEOMETRYANALYZER_H
+#define QGSGEOMETRYANALYZER_H
+/** \ingroup analysis
+ * The QGis class provides vector geometry analysis functions
+ */
+
+class ANALYSIS_EXPORT QgsAnalysisExport
+{
+ public:
+
+bool single_to_multi( );
+bool multi_to_single( );
+bool extract_nodes( );
+bool polygons_to_lines( );
+bool export_geometry_info( );
+bool simplify_geometry( );
+bool polygon_centroids( );
+bool delaunay_triangulation( );
+bool layer_extent( );
+bool extractAsSimple( geom, tolerance );
+bool simplifyLine( ln, typ, tol );
+bool recursiveDouglasPeucker( line, tol, j, k );
+bool shortestDistance( tline, point);
+bool simpleMeasure( inGeom );
+bool perimMeasure( inGeom, measure );
+bool checkForField( L, e );
+bool checkGeometryFields( vlayer );
+bool extractAsLine( geom );
+bool extractAsSingle( geom );
+bool extractAsMulti( geom );
+bool convertGeometry( geom_list, vType );
+
+}
More information about the QGIS-commit
mailing list