def regularMatrix(self, writer, provider1, provider2, index1, index2, nearest, distArea, sindex, progressBar):
inFeat = QgsFeature()
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
first = True
start = 15.00
add = 85.00 / provider1.featureCount()
fit1 = provider1.getFeatures()
while fit1.nextFeature(inFeat):
inGeom = inFeat.geometry()
inID = inFeat.attributes()[index1]
if first:
featList = sindex.nearestNeighbor(inGeom.asPoint(), nearest)
first = False
data = ["ID"]
for i in featList:
provider2.getFeatures(QgsFeatureRequest().setFilterFid(int(i)).setSubsetOfAttributes([index2])).nextFeature(outFeat)
data.append(unicode(outFeat.attributes()[index2]))
writer.writerow(data)
data = [unicode(inID)]
for j in featList:
provider2.getFeatures(QgsFeatureRequest().setFilterFid(int(j))).nextFeature(outFeat)
outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(), outGeom.asPoint())
data.append(unicode(float(dist)))
writer.writerow(data)
start = start + add
progressBar.setValue(start)
del writer
def linearMatrix(self, writer, provider1, provider2, index1, index2, nearest, distArea, matType, sindex, progressBar):
inFeat = QgsFeature()
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
start = 15.00
add = 85.00 / provider1.featureCount()
fit1 = provider1.getFeatures()
while fit1.nextFeature(inFeat):
inGeom = inFeat.geometry()
inID = inFeat.attributes()[index1]
featList = sindex.nearestNeighbor(inGeom.asPoint(), nearest)
distList = []
vari = 0.00
for i in featList:
provider2.getFeatures(QgsFeatureRequest().setFilterFid(int(i)).setSubsetOfAttributes([index2])).nextFeature(outFeat)
outID = outFeat.attributes()[index2]
outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(), outGeom.asPoint())
if dist > 0:
if matType == "Linear":
writer.writerow([unicode(inID), unicode(outID), unicode(dist)])
else:
distList.append(float(dist))
if matType == "Summary":
mean = sum(distList) / len(distList)
for i in distList:
vari = vari + ((i - mean) * (i - mean))
vari = sqrt(vari / len(distList))
writer.writerow([unicode(inID), unicode(mean), unicode(vari), unicode(min(distList)), unicode(max(distList))])
start = start + add
progressBar.setValue(start)
del writer
def linearMatrix(self, inLayer, inField, targetLayer, targetField,
matType, nPoints, progress):
if matType == 0:
self.writer.addRecord(['InputID', 'TargetID', 'Distance'])
else:
self.writer.addRecord(['InputID', 'MEAN', 'STDDEV', 'MIN', 'MAX'])
index = vector.spatialindex(targetLayer)
inIdx = inLayer.fieldNameIndex(inField)
outIdx = targetLayer.fieldNameIndex(targetField)
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
distArea = QgsDistanceArea()
features = vector.features(inLayer)
current = 0
total = 100.0 / float(len(features))
for inFeat in features:
inGeom = inFeat.geometry()
inID = unicode(inFeat.attributes()[inIdx])
featList = index.nearestNeighbor(inGeom.asPoint(), nPoints)
distList = []
vari = 0.0
for i in featList:
request = QgsFeatureRequest().setFilterFid(i)
outFeat = targetLayer.getFeatures(request).next()
outID = outFeat.attributes()[outIdx]
outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(),
outGeom.asPoint())
if matType == 0:
self.writer.addRecord([inID, unicode(outID), unicode(dist)])
else:
distList.append(float(dist))
if matType != 0:
mean = sum(distList) / len(distList)
for i in distList:
vari += (i - mean) * (i - mean)
vari = math.sqrt(vari / len(distList))
self.writer.addRecord([inID, unicode(mean),
unicode(vari), unicode(min(distList)),
unicode(max(distList))])
current += 1
progress.setPercentage(int(current * total))
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
buf = self.getParameterValue(self.BUFFER)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.pendingFields().toList(), QGis.WKBPolygon, layer.crs())
inFeat = QgsFeature()
outFeat = QgsFeature()
extent = layer.extent()
extraX = extent.height() * (buf / 100.0)
extraY = extent.width() * (buf / 100.0)
height = extent.height()
width = extent.width()
c = voronoi.Context()
pts = []
ptDict = {}
ptNdx = -1
features = vector.features(layer)
for inFeat in features:
geom = QgsGeometry(inFeat.geometry())
point = geom.asPoint()
x = point.x() - extent.xMinimum()
y = point.y() - extent.yMinimum()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = inFeat.id()
if len(pts) < 3:
raise GeoAlgorithmExecutionException(
self.tr('Input file should contain at least 3 points. Choose '
'another file and try again.'))
uniqueSet = Set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(i[0], i[1], sitenum=j) for (j,
i) in enumerate(uniqueSet)])
voronoi.voronoi(sl, c)
inFeat = QgsFeature()
current = 0
total = 100.0 / float(len(c.polygons))
for (site, edges) in c.polygons.iteritems():
request = QgsFeatureRequest().setFilterFid(ptDict[ids[site]])
inFeat = layer.getFeatures(request).next()
lines = self.clip_voronoi(edges, c, width, height, extent, extraX, extraY)
geom = QgsGeometry.fromMultiPoint(lines)
geom = QgsGeometry(geom.convexHull())
outFeat.setGeometry(geom)
outFeat.setAttributes(inFeat.attributes())
writer.addFeature(outFeat)
current += 1
progress.setPercentage(int(current * total))
del writer
def draw(self, rows, con, args, geomType, canvasItemList, mapCanvas):
''' draw the result '''
resultNodesVertexMarkers = canvasItemList['markers']
schema = """%(edge_schema)s""" % args
table = """%(edge_table)s_vertices_pgr""" % args
srid, geomType = Utils.getSridAndGeomType(con, schema, table, 'the_geom')
Utils.setTransformQuotes(args, srid, args['canvas_srid'])
for row in rows:
cur2 = con.cursor()
if args['version'] < 2.1:
args['result_node_id'] = row[1]
args['result_edge_id'] = row[2]
args['result_cost'] = row[3]
else:
args['result_node_id'] = row[3]
args['result_edge_id'] = row[4]
args['result_cost'] = row[5]
query2 = sql.SQL("""
SELECT ST_AsText(%(transform_s)s the_geom %(transform_e)s)
FROM %(edge_table)s_vertices_pgr
WHERE id = %(result_node_id)d
""").format(**args)
cur2.execute(query2)
row2 = cur2.fetchone()
if (row2):
geom = QgsGeometry().fromWkt(str(row2[0]))
pt = geom.asPoint()
vertexMarker = QgsVertexMarker(mapCanvas)
vertexMarker.setColor(Qt.red)
vertexMarker.setPenWidth(2)
vertexMarker.setIconSize(5)
vertexMarker.setCenter(QgsPointXY(pt))
resultNodesVertexMarkers.append(vertexMarker)
def regularMatrix(self, inLayer, inField, targetLayer, targetField,
nPoints, progress):
index = vector.spatialindex(targetLayer)
inIdx = inLayer.fieldNameIndex(inField)
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
distArea = QgsDistanceArea()
first = True
current = 0
features = vector.features(inLayer)
total = 100.0 / float(len(features))
for inFeat in features:
inGeom = inFeat.geometry()
inID = unicode(inFeat.attributes()[inIdx])
featList = index.nearestNeighbor(inGeom.asPoint(), nPoints)
if first:
first = False
data = ['ID']
for i in range(len(featList)):
data.append('DIST_{0}'.format(i + 1))
self.writer.addRecord(data)
data = [inID]
for i in featList:
request = QgsFeatureRequest().setFilterFid(i)
outFeat = targetLayer.getFeatures(request).next()
outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(),
outGeom.asPoint())
data.append(unicode(float(dist)))
self.writer.addRecord(data)
current += 1
progress.setPercentage(int(current * total))
def regularMatrix(self, inLayer, inField, targetLayer, targetField,
nPoints, progress):
index = vector.spatialindex(targetLayer)
inIdx = inLayer.fieldNameIndex(inField)
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
distArea = QgsDistanceArea()
first = True
current = 0
features = vector.features(inLayer)
total = 100.0 / float(len(features))
for inFeat in features:
inGeom = inFeat.geometry()
inID = unicode(inFeat.attributes()[inIdx])
featList = index.nearestNeighbor(inGeom.asPoint(), nPoints)
if first:
first = False
data = ['ID']
for i in range(len(featList)):
data.append('DIST_{0}'.format(i + 1))
self.writer.addRecord(data)
data = [inID]
for i in featList:
request = QgsFeatureRequest().setFilterFid(i)
outFeat = targetLayer.getFeatures(request).next()
outGeom = outFeat.geometry()
dist = distArea.measureLine(inGeom.asPoint(),
outGeom.asPoint())
data.append(unicode(float(dist)))
self.writer.addRecord(data)
current += 1
progress.setPercentage(int(current * total))
def voronoi_polygons(self):
vprovider = self.vlayer.dataProvider()
writer = QgsVectorFileWriter(self.myName, self.myEncoding, vprovider.fields(),
QGis.WKBPolygon, vprovider.crs())
inFeat = QgsFeature()
outFeat = QgsFeature()
extent = self.vlayer.extent()
extraX = extent.height() * (self.myParam / 100.00)
extraY = extent.width() * (self.myParam / 100.00)
height = extent.height()
width = extent.width()
c = voronoi.Context()
pts = []
ptDict = {}
ptNdx = -1
fit = vprovider.getFeatures()
while fit.nextFeature(inFeat):
geom = QgsGeometry(inFeat.geometry())
point = geom.asPoint()
x = point.x() - extent.xMinimum()
y = point.y() - extent.yMinimum()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = inFeat.id()
self.vlayer = None
if len(pts) < 3:
return False
uniqueSet = Set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(i[0], i[1], sitenum=j) for j, i in enumerate(uniqueSet)])
voronoi.voronoi(sl, c)
inFeat = QgsFeature()
nFeat = len(c.polygons)
nElement = 0
self.emit(SIGNAL("runStatus( PyQt_PyObject )"), 0)
self.emit(SIGNAL("runRange( PyQt_PyObject )"), (0, nFeat))
for site, edges in c.polygons.iteritems():
vprovider.getFeatures(QgsFeatureRequest().setFilterFid(ptDict[ids[site]])).nextFeature(inFeat)
lines = self.clip_voronoi(edges, c, width, height, extent, extraX, extraY)
geom = QgsGeometry.fromMultiPoint(lines)
geom = QgsGeometry(geom.convexHull())
outFeat.setGeometry(geom)
outFeat.setAttributes(inFeat.attributes())
writer.addFeature(outFeat)
nElement += 1
self.emit(SIGNAL("runStatus( PyQt_PyObject )"), nElement)
del writer
return True
def voronoi_polygons( self ):
vprovider = self.vlayer.dataProvider()
writer = QgsVectorFileWriter( self.myName, self.myEncoding, vprovider.fields(),
QGis.WKBPolygon, vprovider.crs() )
inFeat = QgsFeature()
outFeat = QgsFeature()
extent = self.vlayer.extent()
extraX = extent.height() * ( self.myParam / 100.00 )
extraY = extent.width() * ( self.myParam / 100.00 )
height = extent.height()
width = extent.width()
c = voronoi.Context()
pts = []
ptDict = {}
ptNdx = -1
fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
geom = QgsGeometry( inFeat.geometry() )
point = geom.asPoint()
x = point.x() - extent.xMinimum()
y = point.y() - extent.yMinimum()
pts.append( ( x, y ) )
ptNdx +=1
ptDict[ ptNdx ] = inFeat.id()
self.vlayer = None
if len( pts ) < 3:
return False
uniqueSet = Set( item for item in pts )
ids = [ pts.index( item ) for item in uniqueSet ]
sl = voronoi.SiteList( [ voronoi.Site( i[ 0 ], i[ 1 ], sitenum=j ) for j, i in enumerate( uniqueSet ) ] )
voronoi.voronoi( sl, c )
inFeat = QgsFeature()
nFeat = len( c.polygons )
nElement = 0
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), 0 )
self.emit( SIGNAL( "runRange( PyQt_PyObject )" ), ( 0, nFeat ) )
for site, edges in c.polygons.iteritems():
vprovider.getFeatures( QgsFeatureRequest().setFilterFid( ptDict[ ids[ site ] ] ) ).nextFeature( inFeat )
lines = self.clip_voronoi( edges, c, width, height, extent, extraX, extraY )
geom = QgsGeometry.fromMultiPoint( lines )
geom = QgsGeometry( geom.convexHull() )
outFeat.setGeometry( geom )
outFeat.setAttributes( inFeat.attributes() )
writer.addFeature( outFeat )
nElement += 1
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
del writer
return True
def zoom(self, error, crs):
if not error: return
geo = error.geo
mapSettings = self.mapCanvas.mapSettings()
if isProjectCrsEnabled() and getProjectCrs() != crs:
geo = QgsGeometry(error.geo)
transform = QgsCoordinateTransform(crs, QgsProject().instance().crs())
geo.transform(transform)
if geo.type() == QgsWkbTypes.PointGeometry:
p = geo.asPoint()
bufferCrs = getProjectCrs() if isProjectCrsEnabled() else crs
b = 2000 if not bufferCrs.isGeographic() else 2000 / 100000 # buffer
extent = QgsRectangle(p.x() - b, p.y() - b, p.x() + b, p.y() + b)
else: # line
extent = geo.boundingBox()
extent.scale(2)
self.mapCanvas.setExtent(extent)
self.mapCanvas.refresh();
def do_indexjoin(self, feat):
'''Find the nearest neigbour using an index, if possible
Parameter: feat -- The feature for which a neighbour is
sought
'''
infeature = feat
infeatureid = infeature.id()
inputgeom = QgsGeometry(infeature.geometry())
# Shall approximate input geometries be used?
if self.approximateinputgeom:
# Use the centroid as the input geometry
inputgeom = QgsGeometry(infeature.geometry()).centroid()
# Check if the coordinate systems are equal, if not,
# transform the input feature!
if (self.inpvl.crs() != self.joinvl.crs()):
try:
inputgeom.transform(QgsCoordinateTransform(
self.inpvl.crs(), self.joinvl.crs()))
except:
import traceback
self.error.emit(self.tr('CRS Transformation error!') +
' - ' + traceback.format_exc())
self.abort = True
return
nnfeature = None
mindist = float("inf")
## Find the closest feature!
if (self.approximateinputgeom or
self.inpvl.wkbType() == QGis.WKBPoint or
self.inpvl.wkbType() == QGis.WKBPoint25D):
# The input layer's geometry type is point, or shall be
# approximated to point (centroid).
# Then a join index will always be used.
if (self.usejoinlayerapprox or
self.joinvl.wkbType() == QGis.WKBPoint or
self.joinvl.wkbType() == QGis.WKBPoint25D):
# The join layer's geometry type is point, or the
# user wants approximate join geometries to be used.
# Then the join index nearest neighbour function can
# be used without refinement.
if self.selfjoin:
# Self join!
# Have to get the two nearest neighbours
nearestids = self.joinlind.nearestNeighbor(
inputgeom.asPoint(), 2)
if nearestids[0] == infeatureid and len(nearestids) > 1:
# The first feature is the same as the input
# feature, so choose the second one
nnfeature = self.joinvl.getFeatures(
QgsFeatureRequest(nearestids[1])).next()
else:
# The first feature is not the same as the
# input feature, so choose it
nnfeature = self.joinvl.getFeatures(
QgsFeatureRequest(nearestids[0])).next()
## Pick the second closest neighbour!
## (the first is supposed to be the point itself)
## Should we check for coinciding points?
#nearestid = self.joinlind.nearestNeighbor(
# inputgeom.asPoint(), 2)[1]
#nnfeature = self.joinvl.getFeatures(
# QgsFeatureRequest(nearestid)).next()
else:
# Not a self join, so we can search for only the
# nearest neighbour (1)
nearestid = self.joinlind.nearestNeighbor(
inputgeom.asPoint(), 1)[0]
nnfeature = self.joinvl.getFeatures(
QgsFeatureRequest(nearestid)).next()
mindist = inputgeom.distance(nnfeature.geometry())
elif (self.joinvl.wkbType() == QGis.WKBPolygon or
self.joinvl.wkbType() == QGis.WKBPolygon25D or
self.joinvl.wkbType() == QGis.WKBLineString or
self.joinvl.wkbType() == QGis.WKBLineString25D):
# Use the join layer index to speed up the join when
# the join layer geometry type is polygon or line
# and the input layer geometry type is point or an
# approximation (point)
nearestindexid = self.joinlind.nearestNeighbor(
inputgeom.asPoint(), 1)[0]
# Check for self join
if self.selfjoin and nearestindexid == infeatureid:
# Self join and same feature, so get the two
# first two neighbours
nearestindexes = self.joinlind.nearestNeighbor(
inputgeom.asPoint(), 2)
nearestindexid = nearestindexes[0]
if (nearestindexid == infeatureid and
len(nearestindexes) > 1):
nearestindexid = nearestindexes[1]
nnfeature = self.joinvl.getFeatures(
QgsFeatureRequest(nearestindexid)).next()
mindist = inputgeom.distance(nnfeature.geometry())
px = inputgeom.asPoint().x()
py = inputgeom.asPoint().y()
closefids = self.joinlind.intersects(QgsRectangle(
px - mindist,
py - mindist,
px + mindist,
py + mindist))
for closefid in closefids:
if self.abort is True:
break
# Check for self join and same feature
if self.selfjoin and closefid == infeatureid:
continue
closef = self.joinvl.getFeatures(
QgsFeatureRequest(closefid)).next()
thisdistance = inputgeom.distance(closef.geometry())
if thisdistance < mindist:
mindist = thisdistance
nnfeature = closef
if mindist == 0:
break
else:
# Join with no index use
# Go through all the features from the join layer!
for inFeatJoin in self.joinf:
if self.abort is True:
break
joingeom = QgsGeometry(inFeatJoin.geometry())
thisdistance = inputgeom.distance(joingeom)
# If the distance is 0, check for equality of the
# features (in case it is a self join)
if (thisdistance == 0 and self.selfjoin and
infeatureid == inFeatJoin.id()):
continue
if thisdistance < mindist:
mindist = thisdistance
nnfeature = inFeatJoin
# For 0 distance, settle with the first feature
if mindist == 0:
break
else:
# non-simple point input geometries (could be multipoint)
if (self.nonpointexactindex):
# Use the spatial index on the join layer (default).
# First we do an approximate search
# Get the input geometry centroid
centroid = QgsGeometry(infeature.geometry()).centroid()
centroidgeom = centroid.asPoint()
# Find the nearest neighbour (index geometries only)
nearestid = self.joinlind.nearestNeighbor(centroidgeom, 1)[0]
# Check for self join
if self.selfjoin and nearestid == infeatureid:
# Self join and same feature, so get the two
# first two neighbours
nearestindexes = self.joinlind.nearestNeighbor(
centroidgeom, 2)
nearestid = nearestindexes[0]
if nearestid == infeatureid and len(nearestindexes) > 1:
nearestid = nearestindexes[1]
nnfeature = self.joinvl.getFeatures(
QgsFeatureRequest(nearestid)).next()
mindist = inputgeom.distance(nnfeature.geometry())
# Calculate the search rectangle (inputgeom BBOX
inpbbox = infeature.geometry().boundingBox()
minx = inpbbox.xMinimum() - mindist
maxx = inpbbox.xMaximum() + mindist
miny = inpbbox.yMinimum() - mindist
maxy = inpbbox.yMaximum() + mindist
#minx = min(inpbbox.xMinimum(), centroidgeom.x() - mindist)
#maxx = max(inpbbox.xMaximum(), centroidgeom.x() + mindist)
#miny = min(inpbbox.yMinimum(), centroidgeom.y() - mindist)
#maxy = max(inpbbox.yMaximum(), centroidgeom.y() + mindist)
searchrectangle = QgsRectangle(minx, miny, maxx, maxy)
# Fetch the candidate join geometries
closefids = self.joinlind.intersects(searchrectangle)
# Loop through the geometries and choose the closest
# one
for closefid in closefids:
if self.abort is True:
break
# Check for self join and identical feature
if self.selfjoin and closefid == infeatureid:
continue
closef = self.joinvl.getFeatures(
QgsFeatureRequest(closefid)).next()
thisdistance = inputgeom.distance(closef.geometry())
if thisdistance < mindist:
mindist = thisdistance
nnfeature = closef
if mindist == 0:
break
else:
# Join with no index use
# Check all the features of the join layer!
mindist = float("inf") # should not be necessary
for inFeatJoin in self.joinf:
if self.abort is True:
break
joingeom = QgsGeometry(inFeatJoin.geometry())
thisdistance = inputgeom.distance(joingeom)
# If the distance is 0, check for equality of the
# features (in case it is a self join)
if (thisdistance == 0 and self.selfjoin and
infeatureid == inFeatJoin.id()):
continue
if thisdistance < mindist:
mindist = thisdistance
nnfeature = inFeatJoin
# For 0 distance, settle with the first feature
if mindist == 0:
break
if not self.abort:
atMapA = infeature.attributes()
atMapB = nnfeature.attributes()
attrs = []
attrs.extend(atMapA)
attrs.extend(atMapB)
attrs.append(mindist)
outFeat = QgsFeature()
# Use the original input layer geometry!:
outFeat.setGeometry(QgsGeometry(infeature.geometry()))
# Use the modified input layer geometry (could be
# centroid)
#outFeat.setGeometry(QgsGeometry(inputgeom))
outFeat.setAttributes(attrs)
self.calculate_progress()
self.features.append(outFeat)
def traf(self,geometry,trafic,spatial,lines,echelle,angle_max,dist_min,double_sens):
lignes=lines
conn = db.connect(':memory:')
conn.enable_load_extension(True)
conn.execute("select load_extension('mod_spatialite')")
c = conn.cursor()
proj=str(self.lines.crs().postgisSrid())
t=geometry[trafic]
texte="select astext(st_buffer(st_geomfromtext('"+geometry.geometry().asWkt()+"',"+proj+"),"+str(echelle*t)+"))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
texte_buf= resultat[0][0]
texte_buf=texte_buf.replace("Polygon","MultiLineString")
buf=QgsGeometry.fromWkt(texte_buf)
#buf=buf.convertToType(QgsWkbTypes.LineGeometry,False)
texte="select astext(st_union(st_exteriorring(st_geomfromtext('"+buf.asWkt()+"',"+proj+"))))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf= QgsGeometry.fromWkt(resultat[0][0])
#QgsMessageLog.logMessage(texte)
#QgsMessageLog.logMessage(buf.asWkt())
buf_poly=buf
geom=geometry.geometry()
buf_sav=buf
buf_l=buf.length()
l2=QgsLineString()
#print(geom.asWkt())
geom.convertToSingleType()
#print(geom.asWkt())
l2.fromWkt(geom.asWkt())
#print(l2.asWkt())
pt1=QgsGeometry(l2.startPoint())
pt2=QgsGeometry(l2.endPoint())
###point debut
debut=spatial.intersects(QgsGeometry.buffer(pt1,10,3).boundingBox())
fe= [f for f in debut]
feats=[]
for f in fe:
ff=QgsLineString()
#QgsMessageLog.logMessage(lignes[f].geometry().asWkt())
geom=lignes[f].geometry()
geom.convertToSingleType()
ff.fromWkt(geom.asWkt())
#QgsMessageLog.logMessage(ff.asWkt())
#print(pt1.distance(QgsGeometry(ff.startPoint())))
if pt1.distance(QgsGeometry(ff.startPoint()))<10:
if lignes[f] not in feats:
feats.append(f)
elif pt1.distance(QgsGeometry(ff.endPoint()))<10:
if lignes[f] not in feats:
feats.append(f)
#QgsMessageLog.logMessage(str(fe))
#QgsMessageLog.logMessage(str(feats))
distances={}
angles={}
for i in feats:
longueur=lignes[i].geometry().length()
if not(geometry.id()==i):
distances[i]=lignes[i].geometry().lineLocatePoint(pt1)
if distances[i]<dist_min:
angles[i]=((lignes[i].geometry().interpolateAngle(min(dist_min,longueur))*180/math.pi)+180)%360
else:
angles[i]=lignes[i].geometry().interpolateAngle(longueur-min(dist_min,longueur))*180/math.pi
else:
angle1=lignes[i].geometry().interpolateAngle(min(dist_min,longueur))*180/math.pi
angle_maxi=1e38
voisin=None
angle_voisin=None
angle2=None
if len(distances)==0:
angle=(angle1)%360
angle2=angle1
angle_voisin=angle2
for i in distances:
if distances[i]<dist_min:
angle=(angles[i])%360
min_angle=min(abs((angle+180)%360-(angle1+180)%360),abs(angle-angle1))
if min_angle<angle_maxi:
angle_maxi=min_angle
angle_voisin=angle
voisin=i
else:
angle=angles[i]
min_angle=min(abs((angle+180)%360-(angle1+180)%360),abs(angle-angle1))
if min_angle<angle_maxi:
angle_maxi=min_angle
angle_voisin=angle
voisin=i
if min(abs((angle_voisin+180)%360-(angle1+180)%360),abs(angle_voisin-angle1))<angle_max:
if abs((angle_voisin+180)%360-(angle1+180)%360)<abs(angle_voisin-angle1):
angle2=(0.5*(((angle_voisin+180)%360+(angle1+180)%360))+180)%360
else:
angle2=0.5*(angle_voisin+angle1)
else:
angle2=angle1
if angle2==None:
angle2=(angle1)%360
start_line=QgsGeometry.fromPolyline([QgsPoint(pt1.asPoint().x()-40*echelle*t*math.cos((180-angle2)*math.pi/180),pt1.asPoint().y()-40*echelle*t*math.sin((180-angle2)*math.pi/180)),QgsPoint(pt1.asPoint().x(),pt1.asPoint().y())])
int1=buf.intersection(start_line)
start_line2=QgsGeometry.fromPolyline([QgsPoint(pt1.asPoint().x()+40*echelle*t*math.cos((180-angle2)*math.pi/180),pt1.asPoint().y()+40*echelle*t*math.sin((180-angle2)*math.pi/180)),QgsPoint(pt1.asPoint().x(),pt1.asPoint().y())])
int3=buf.intersection(start_line2)
if int1.isMultipart():
points=int1.asMultiPoint()
dmax=1e38
for p in points:
d=pt1.distance(QgsGeometry.fromPointXY(p))
if d<dmax:
dmax=d
pmax=p
int1=QgsGeometry.fromPointXY(pmax)
if int3.isMultipart():
points=int3.asMultiPoint()
dmax=1e38
for p in points:
d=pt1.distance(QgsGeometry.fromPointXY(p))
if d<dmax:
dmax=d
pmax=p
int3=QgsGeometry.fromPointXY(pmax)
###point fin
debut=spatial.intersects(QgsGeometry.buffer(pt2,10,3).boundingBox())
fe= [f for f in debut]
for f in fe:
ff=QgsLineString()
geom=lignes[f].geometry()
geom.convertToSingleType()
ff.fromWkt(geom.asWkt())
if pt2.distance(QgsGeometry(ff.startPoint()))<10:
if lignes[f] not in feats:
feats.append(f)
elif pt2.distance(QgsGeometry(ff.endPoint()))<10:
if lignes[f] not in feats:
feats.append(f)
distances={}
angles={}
for i in feats:
longueur=lignes[i].geometry().length()
if not(geometry.id()==i):
distances[i]=lignes[i].geometry().lineLocatePoint(pt2)
if distances[i]<dist_min:
angles[i]=(lignes[i].geometry().interpolateAngle(min(dist_min,longueur))*180/math.pi)%360
else:
angles[i]=(((lignes[i].geometry().interpolateAngle(longueur-min(dist_min,longueur))*180)/math.pi)+180)%360
else:
angle1=((lignes[i].geometry().interpolateAngle(longueur-min(dist_min,longueur))*180/math.pi))
angle_maxi=1e38
voisin=None
angle_voisin=None
angle2=None
if len(distances)==0:
angle=(angle1)%360
angle2=angle1
angle_voisin=angle2
for i in distances:
if distances[i]<dist_min:
angle=(angles[i])
min_angle=min(abs((angle+180)%360-(angle1+180)%360),abs(angle-angle1))
if min_angle<angle_maxi:
angle_maxi=min_angle
angle_voisin=angle
voisin=i
else:
angle=(angles[i])
min_angle=min(abs((angle+180)%360-(angle1+180)%360),abs(angle-angle1))
if min_angle<angle_maxi:
angle_maxi=min_angle
angle_voisin=angle
voisin=i
if min(abs((angle_voisin+180)%360-(angle1+180)%360),abs(angle_voisin-angle1))<angle_max:
if abs((angle_voisin+180)%360-(angle1+180)%360)<abs(angle_voisin-angle1):
angle2=(0.5*(((angle_voisin+180)%360+(angle1+180)%360))+180)%360
else:
angle2=0.5*(angle_voisin+angle1)
else:
angle2=angle1
if angle2==None:
angle2=(angle1)%360
end_line=QgsGeometry.fromPolyline([QgsPoint(pt2.asPoint().x()-40*echelle*t*math.cos((180-angle2)*math.pi/180),pt2.asPoint().y()-40*echelle*t*math.sin((180-angle2)*math.pi/180)),QgsPoint(pt2.asPoint().x(),pt2.asPoint().y())])
int2=buf.intersection(end_line)
end_line2=QgsGeometry.fromPolyline([QgsPoint(pt2.asPoint().x()+40*echelle*t*math.cos((180-angle2)*math.pi/180),pt2.asPoint().y()+40*echelle*t*math.sin((180-angle2)*math.pi/180)),QgsPoint(pt2.asPoint().x(),pt2.asPoint().y())])
int4=buf.intersection(end_line2)
int5=start_line.intersection(end_line)
int6=start_line2.intersection(end_line2)
m5=-1
m6=-1
if int5.type()==0:
if int5.within(buf_poly):
m5=1
if int6.type()==0:
if int6.within(buf_poly):
m6=1
if int2.isMultipart():
points=int2.asMultiPoint()
dmax=1e38
for p in points:
d=pt2.distance(QgsGeometry.fromPointXY(p))
if d<dmax:
dmax=d
pmax=p
int2=QgsGeometry.fromPointXY(pmax)
if int4.isMultipart():
points=int4.asMultiPoint()
dmax=1e38
for p in points:
d=pt2.distance(QgsGeometry.fromPointXY(p))
if d<dmax:
dmax=d
pmax=p
int4=QgsGeometry.fromPointXY(pmax)
#print(int1.exportToWkt(),int2.exportToWkt(),int3.exportToWkt(),int4.exportToWkt())
#QgsMessageLog.logMessage(buf.asWkt())
texte="select astext(st_union(st_snap(st_geomfromtext('"+buf.asWkt()+"',"+proj+"),st_geomfromtext('"+int1.asWkt()+"',"+proj+"),1)))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf= resultat[0][0]
#QgsMessageLog.logMessage(texte)
#QgsMessageLog.logMessage(buf)
#QgsMessageLog.logMessage(proj)
#QgsMessageLog.logMessage(int2.asWkt())
texte="select astext(st_union(st_snap(st_geomfromtext('"+buf+"',"+proj+"),st_geomfromtext('"+int2.asWkt()+"',"+proj+"),1)))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf= resultat[0][0]
texte="select astext(st_union(st_snap(st_geomfromtext('"+buf+"',"+proj+"),st_geomfromtext('"+int3.asWkt()+"',"+proj+"),1)))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf= resultat[0][0]
texte="select astext(st_union(st_snap(st_geomfromtext('"+buf+"',"+proj+"),st_geomfromtext('"+int4.asWkt()+"',"+proj+"),1)))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf= QgsGeometry.fromWkt(resultat[0][0])
m1=buf.lineLocatePoint(int1)
m2=buf.lineLocatePoint(int2)
m3=buf.lineLocatePoint(int3)
m4=buf.lineLocatePoint(int4)
#creation epaisseur
buf_l=buf.length()
m1=m1/buf_l
m2=m2/buf_l
m3=m3/buf_l
m4=m4/buf_l
if m2<m1:
texte="select asText(st_line_substring(st_geomfromtext('"+buf.asWkt()+"',"+proj+")"+','+str(m2)+','+str(m1)+"))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf1= QgsGeometry.fromWkt(resultat[0][0])
else:
texte="select astext(st_union(st_snap(st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),0,"+str(m1)+"),st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m3)+",1),1),st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m2)+",1)))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf1= QgsGeometry.fromWkt(resultat[0][0])
if m3<m4:
texte="select asText(st_line_substring(st_geomfromtext('"+buf.asWkt()+"',"+proj+")"+','+str(m3)+','+str(m4)+"))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf2= QgsGeometry.fromWkt(resultat[0][0])
else:
texte="select astext(st_union(g)) from (select st_line_substring(st_geomfromtext('"+buf.asWkt()+"',"+proj+"),0,"+str(m4)+") as \"g\" union all select st_line_substring(st_geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m3)+",1) as \"g\" )"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf2= QgsGeometry.fromWkt(resultat[0][0])
texte="select astext(st_union(st_snap(st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),0,"+str(m4)+"),st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m3)+",1),1),st_line_substring(geomfromtext('"+buf.asWkt()+"',"+proj+"),"+str(m3)+",1)))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf2= QgsGeometry.fromWkt(resultat[0][0])
g1=buf
g2=buf.shortestLine(int1)
g2=g2.combine(g1)
g3=buf.shortestLine(int2)
g3=g3.combine(g2)
g3=g3.combine(pt1.shortestLine(int1))
g3=g3.combine(pt2.shortestLine(int2))
g3=g3.combine(pt1.shortestLine(geometry.geometry()))
g3=g3.combine(pt2.shortestLine(geometry.geometry()))
g3=g3.combine(geometry.geometry())
buf3=buf1.asWkt()
buf4=buf2.asWkt()
if double_sens==False:
if m5>0:
texte="select astext(st_union(st_snap(geomfromtext('"+geometry.geometry().asWkt()+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int5).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int5).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int5).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int5).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
else:
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf1.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+buf1.shortestLine(int1).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf1.shortestLine(int2).asWkt()+"',"+proj+"),1),geomfromtext('"+buf1.shortestLine(int2).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int1).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int2).asWkt()+"'),1),geomfromtext('"+pt2.shortestLine(int2).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(geometry.geometry()).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(geometry.geometry()).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(geometry.geometry()).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(geometry.geometry()).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+geometry.geometry().asWkt()+"',"+proj+"),1),geomfromtext('"+geometry.geometry().asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
else:
if m5>0:
texte="select astext(st_union(st_snap(geomfromtext('"+buf4+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int3).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int3).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int4).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int4).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int5).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int5).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int5).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int5).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
elif m6>0:
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int1).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int2).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int2).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt1.shortestLine(int6).asWkt()+"',"+proj+"),1),geomfromtext('"+pt1.shortestLine(int6).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+pt2.shortestLine(int6).asWkt()+"',"+proj+"),1),geomfromtext('"+pt2.shortestLine(int6).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
else:
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf1.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+buf1.shortestLine(int1).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf1.shortestLine(int2).asWkt()+"',"+proj+"),1),geomfromtext('"+buf1.shortestLine(int2).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+int3.shortestLine(int1).asWkt()+"',"+proj+"),1),geomfromtext('"+int3.shortestLine(int1).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+int4.shortestLine(int2).asWkt()+"',"+proj+"),1),geomfromtext('"+int4.shortestLine(int2).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf2.shortestLine(int3).asWkt()+"',"+proj+"),1),geomfromtext('"+buf2.shortestLine(int3).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf2.shortestLine(int4).asWkt()+"',"+proj+"),1),geomfromtext('"+buf2.shortestLine(int4).asWkt()+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_union(st_snap(geomfromtext('"+buf3+"',"+proj+"),geomfromtext('"+buf4+"',"+proj+"),1),geomfromtext('"+buf4+"',"+proj+")))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf3= resultat[0][0]
texte="select astext(st_buildarea(st_union(g))) from ((select geomfromtext('"+buf3+"',"+proj+") as \"g\"))"
rs = c.execute(texte)
resultat=c.fetchall()
conn.commit()
buf=QgsGeometry.fromWkt(resultat[0][0])
return(buf)
def processing(options, f, progressBar, progressMessage):
'''
Select trees which are on the contour of the forest and isolated trees.
'''
# Export Grid contour and isolated to crowns values
forestSelectedPath = options['dst'] + 'tif/' + f + \
'_forest_selected.tif'
crownsPath = options['dst'] + 'shp/' + f + '_crowns.shp'
# crownsStatsPath = options['dst'] + 'shp/' + f + '_crowns_stats.shp'
outputDir = options["dst"]
fileTxt = open(outputDir + "/log.txt", "a")
fileTxt.write("gridstatisticsforpolygons started\n")
fileTxt.close()
crowns = QgsVectorLayer(crownsPath, "crowns", "ogr")
inputStatRaster = QgsRasterLayer(forestSelectedPath, "forestSelected")
z_stat = QgsZonalStatistics(crowns, inputStatRaster, '_', 1,
QgsZonalStatistics.Max)
result_z_stat = z_stat.calculateStatistics(QgsFeedback())
outputDir = options["dst"]
fileTxt = open(outputDir + "/log.txt", "a")
fileTxt.write("gridstatisticsforpolygons passed\n")
fileTxt.close()
# crowns = QgsVectorLayer(crownsStatsPath, 'Crowns stats', 'ogr')
crowns.selectByExpression('"_max"=1.0')
selected_array = crowns.getValues("N", True)
crowns.invertSelection()
unselected_array = crowns.getValues("N", True)
unselected_crowns_ids = crowns.getValues("$id", True)
unselected_top_ids = crowns.getValues('"N" - 1', True)
crowns.dataProvider().deleteFeatures(unselected_crowns_ids[0])
treetopsPath = options['dst'] + 'shp/' + f + '_treetops.shp'
treetops = QgsVectorLayer(treetopsPath, 'Tree tops', 'ogr')
treetops.dataProvider().deleteFeatures(unselected_top_ids[0])
treetopsSelectedPath = options['dst'] + 'shp/' + f + \
'_treetops_selected.shp'
crownsSelectedPath = options['dst'] + 'shp/' + f + '_crowns_selected.shp'
treetopsTrianglesPath = options['dst'] + 'shp/' + f + \
'_treetops_triangles.shp'
outputDir = options["dst"]
fileTxt = open(outputDir + "/log.txt", "a")
fileTxt.write("advancedpythonfieldcalculator started\n")
fileTxt.close()
treetops.dataProvider().addAttributes([QgsField('N', QVariant.Int)])
treetops.updateFields()
treetops.startEditing()
for treetop in treetops.getFeatures():
treetops.changeAttributeValue(treetop.id(),
treetop.fieldNameIndex('N'),
treetop.id())
treetops.commitChanges()
outputDir = options["dst"]
fileTxt = open(outputDir + "/log.txt", "a")
fileTxt.write("joinattributesbylocation started\n")
fileTxt.close()
# Adapted from https://github.com/qgis/QGIS-Processing
# TODO: replace by native QGIS c++ algo when available...
crowns.dataProvider().addAttributes([QgsField('tid', QVariant.Int)])
crowns.updateFields()
crowns.startEditing()
fcount = crowns.featureCount()
counter = 0
for crown in crowns.getFeatures():
counter += 1
progressBar.setValue(100 + int(counter * (600 / fcount)))
progressMessage.setText('Joining crown ' + str(counter) + '/' +
str(fcount))
request = QgsFeatureRequest()
request.setFilterRect(crown.geometry().boundingBox())
dp = treetops.dataProvider()
for r in dp.getFeatures(request):
if crown.geometry().intersects(r.geometry()):
crowns.changeAttributeValue(crown.id(),
crown.fieldNameIndex('tid'),
r.id())
crowns.commitChanges()
fileTxt = open(outputDir + "/log.txt", "a")
fileTxt.write("delaunaytriangulation started\n")
fileTxt.close()
# delaunay triangulation Adapted from official Python plugin
# TODO: replace by native QGIS c++ algo when available...
fields = QgsFields()
fields.append(QgsField('POINTA', QVariant.Double, '', 24, 15))
fields.append(QgsField('POINTB', QVariant.Double, '', 24, 15))
fields.append(QgsField('POINTC', QVariant.Double, '', 24, 15))
crs = QgsCoordinateReferenceSystem('EPSG:2056')
triangleFile = QgsVectorFileWriter(treetopsTrianglesPath, 'utf-8', fields,
QgsWkbTypes.Polygon, crs,
'ESRI Shapefile')
pts = []
ptDict = {}
ptNdx = -1
c = voronoi.Context()
features = treetops.getFeatures()
total = 100.0 / treetops.featureCount() if treetops.featureCount() else 0
progressMessage.setText('Starting triangulation...')
for current, inFeat in enumerate(features):
geom = QgsGeometry(inFeat.geometry())
if geom.isNull():
continue
if geom.isMultipart():
points = geom.asMultiPoint()
else:
points = [geom.asPoint()]
for n, point in enumerate(points):
x = point.x()
y = point.y()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = (inFeat.id(), n)
progressMessage.setText('Triangulation step 1 ok')
if len(pts) < 3:
raise QgsProcessingException(
'Input file should contain at least 3 points. Choose '
'another file and try again.')
uniqueSet = set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(*i) for i in uniqueSet])
c.triangulate = True
voronoi.voronoi(sl, c)
triangles = c.triangles
feat = QgsFeature()
total = 100.0 / len(triangles) if triangles else 1
for current, triangle in enumerate(triangles):
indices = list(triangle)
indices.append(indices[0])
polygon = []
attrs = []
step = 0
for index in indices:
fid, n = ptDict[ids[index]]
request = QgsFeatureRequest().setFilterFid(fid)
inFeat = next(treetops.getFeatures(request))
geom = QgsGeometry(inFeat.geometry())
point = QgsPoint(geom.asPoint())
polygon.append(point)
if step <= 3:
attrs.append(ids[index])
step += 1
linestring = QgsLineString(polygon)
poly = QgsPolygon()
poly.setExteriorRing(linestring)
feat.setAttributes(attrs)
geometry = QgsGeometry().fromWkt(poly.asWkt())
feat.setGeometry(geometry)
triangleFile.addFeature(feat)
progressMessage.setText('Triangulation terminated')
# Remove triangles with perimeter higher than threshold
triangles = QgsVectorLayer(treetopsTrianglesPath, 'triangles', 'ogr')
maxPeri = str(options['MaxTrianglePerimeter'])
triangles.selectByExpression('$perimeter > ' + maxPeri)
triangles_to_delete_ids = triangles.getValues("$id", True)
triangles.dataProvider().deleteFeatures(triangles_to_delete_ids[0])
outputDir = options["dst"]
fileTxt = open(outputDir + "/log.txt", "a")
fileTxt.write("treeSelector passed\n")
fileTxt.close()
progressMessage.setText('Starting convexhull computing...')
def calculateAzimuthToRoadCentreLine(feature):
# find the shortest line from this point to the road centre line layer
# http://www.lutraconsulting.co.uk/blog/2014/10/17/getting-started-writing-qgis-python-plugins/ - generates "closest feature" function
# QgsMessageLog.logMessage("In setAzimuthToRoadCentreLine(helper):", tag="TOMs panel")
RoadCentreLineLayer = QgsProject.instance().mapLayersByName("RoadCentreLine")[0]
"""if feature.geometry():
geom = feature.geometry()
else:
QgsMessageLog.logMessage("In setAzimuthToRoadCentreLine(helper): geometry not found", tag="TOMs panel")
return 0"""
# take the a point from the geometry
# line = feature.geometry().asPolyline()
line = generateGeometryUtils.getLineForAz(feature)
if len(line) == 0:
return 0
# Get the mid point of the line - https://gis.stackexchange.com/questions/58079/finding-middle-point-midpoint-of-line-in-qgis
testPt = feature.geometry().centroid().asPoint() #lineGeom = QgsGeometry.fromPolyline((line[::])
#lineLength = lineGeom.length()
#QgsMessageLog.logMessage("In setAzimuthToRoadCentreLine(helper): lineLength: " + str(lineLength), tag="TOMs panel")
#testPt = lineGeom.interpolate(lineLength / 2.0)
#testPt = line[0] # choose second point to (try to) move away from any "ends" (may be best to get midPoint ...)
# QgsMessageLog.logMessage("In setAzimuthToRoadCentreLine: secondPt: " + str(testPt.x()), tag="TOMs panel")
# Find all Road Centre Line features within a "reasonable" distance and then check each one to find the shortest distance
tolerance_roadwidth = 25
searchRect = QgsRectangle(testPt.x() - tolerance_roadwidth,
testPt.y() - tolerance_roadwidth,
testPt.x() + tolerance_roadwidth,
testPt.y() + tolerance_roadwidth)
request = QgsFeatureRequest()
request.setFilterRect(searchRect)
request.setFlags(QgsFeatureRequest.ExactIntersect)
shortestDistance = float("inf")
featureFound = False
# Loop through all features in the layer to find the closest feature
for f in RoadCentreLineLayer.getFeatures(request):
dist = f.geometry().distance(QgsGeometry.fromPointXY(testPt))
if dist < shortestDistance:
shortestDistance = dist
closestFeature = f
featureFound = True
# QgsMessageLog.logMessage("In calculateAzimuthToRoadCentreLine: shortestDistance: " + str(shortestDistance), tag="TOMs panel")
if featureFound:
# now obtain the line between the testPt and the nearest feature
# f_lineToCL = closestFeature.geometry().shortestLine(QgsGeometry.fromPointXY(testPt))
startPt = QgsPoint(QgsGeometry.asPoint(closestFeature.geometry().nearestPoint(QgsGeometry.fromPointXY(testPt))))
# get the start point (we know the end point)
"""startPtV2 = f_lineToCL.geometry().startPoint()
startPt = QgsPoint()
startPt.setX(startPtV2.x())
startPt.setY(startPtV2.y())"""
QgsMessageLog.logMessage("In calculateAzimuthToRoadCentreLine: startPoint: " + str(startPt.x()),
tag="TOMs panel")
#Az = QgsPoint(testPt).azimuth(startPt)
Az = generateGeometryUtils.checkDegrees(QgsPoint(testPt).azimuth(startPt))
# QgsMessageLog.logMessage("In calculateAzimuthToRoadCentreLine: Az: " + str(Az), tag="TOMs panel")
return Az
else:
return 0
def processAlgorithm(self, parameters, context, feedback):
try:
# read out algorithm parameters
input_points = self.parameterAsVectorLayer(parameters, self.INPUT, context)
distance_treshold = parameters[self.DISTANCE_TRESHOLD]
result_type_str = [
self.predicates[i][0]
for i in self.parameterAsEnums(parameters, self.RESULT_TYPE, context)
][0]
result_type = LsType[result_type_str]
input_fields = [x.strip() for x in parameters[self.FIELDS].split(",")]
input_layer_fields = input_points.fields()
input_layer_fields_names = [field.name() for field in input_layer_fields]
field_mapping = {}
for input_field in input_fields:
mapped_field_name = input_field
if input_field == "weergavenaam":
mapped_field_name = f"weergavenaam_{result_type.value}"
# TODO: improve field mapping, since no check if ls_{input_field} exists
# in input_layer_fields_names
if mapped_field_name in input_layer_fields_names:
mapped_field_name = f"ls_{input_field}"
field_mapping[input_field] = mapped_field_name
for input_field in input_fields:
input_layer_fields.append(
QgsField(field_mapping[input_field], QVariant.String)
)
(sink, dest_id) = self.parameterAsSink(
parameters,
self.OUTPUT,
context,
input_layer_fields,
QgsWkbTypes.Point,
input_points.sourceCrs(),
)
# Setup transformation if required
in_crs = input_points.crs()
out_crs = QgsCoordinateReferenceSystem.fromEpsgId(28992)
transform = None
if in_crs.authid() != "EPSG:28992":
transform = QgsCoordinateTransform(
in_crs, out_crs, QgsProject.instance()
)
if feedback.isCanceled():
return {}
# start processing features
for point in input_points.getFeatures():
geom = point.geometry()
fid = point.id()
if transform:
geom.transform(transform)
point_geom = QgsGeometry.asPoint(geom)
pxy = QgsPointXY(point_geom)
x = pxy.x()
y = pxy.y()
# afstand field required, add if not requested by user
if "afstand" not in input_fields:
input_fields.append("afstand")
data = reverse_lookup(x, y, input_fields, TypeFilter([result_type]))
# TODO: add exception handling reverse_lookup
result = None
if len(data) > 0:
if (
distance_treshold != None
and data[0]["afstand"] > distance_treshold
):
distance = data[0]["afstand"]
feedback.pushInfo(
f"feature id: {fid} - distance treshold ({distance_treshold}) exceeded: {distance}"
)
pass
else:
result = {}
for key in field_mapping:
if key in data[0]:
result[key] = data[0][key]
else:
feedback.pushInfo(
f'feature id: {fid} - field "{key}" not in response'
)
else:
feedback.pushInfo(
f"feature id: {fid} - no objects found for x,y ({x},{y}) with result_type: {result_type.value}"
)
attrs = point.attributes()
new_ft = QgsFeature(input_layer_fields)
for i in range(len(attrs)):
attr = attrs[i]
field_name = input_layer_fields_names[i]
new_ft.setAttribute(field_name, attr)
for key in result:
new_ft.setAttribute(field_mapping[key], result[key])
new_ft.setGeometry(point.geometry())
sink.addFeature(new_ft, QgsFeatureSink.FastInsert)
if feedback.isCanceled():
return {}
results = {}
results[self.OUTPUT] = dest_id
return results
except Exception as e:
traceback_str = traceback.format_exc()
raise QgsProcessingException(
f"Unexpected error occured while running PDOKReverseGeocoder: {str(e)} - {traceback_str}"
)
def delaunay_triangulation(self):
import voronoi
from sets import Set
vprovider = self.vlayer.dataProvider()
fields = QgsFields()
fields.append(QgsField("POINTA", QVariant.Double))
fields.append(QgsField("POINTB", QVariant.Double))
fields.append(QgsField("POINTC", QVariant.Double))
writer = QgsVectorFileWriter(self.myName, self.myEncoding, fields,
QGis.WKBPolygon, vprovider.crs())
inFeat = QgsFeature()
c = voronoi.Context()
pts = []
ptDict = {}
ptNdx = -1
fit = vprovider.getFeatures()
while fit.nextFeature(inFeat):
geom = QgsGeometry(inFeat.geometry())
point = geom.asPoint()
x = point.x()
y = point.y()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = inFeat.id()
if len(pts) < 3:
return False
uniqueSet = Set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(*i) for i in uniqueSet])
c.triangulate = True
voronoi.voronoi(sl, c)
triangles = c.triangles
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 = []
attrs = []
step = 0
for index in indicies:
vprovider.getFeatures(QgsFeatureRequest().setFilterFid(ptDict[ids[index]])).nextFeature(inFeat)
geom = QgsGeometry(inFeat.geometry())
point = QgsPoint(geom.asPoint())
polygon.append(point)
if step <= 3:
attrs.append(ids[index])
step += 1
feat.setAttributes(attrs)
geometry = QgsGeometry().fromPolygon([polygon])
feat.setGeometry(geometry)
writer.addFeature(feat)
nElement += 1
self.emit(SIGNAL("runStatus( PyQt_PyObject )"), nElement)
del writer
return True
def processAlgorithm(self, parameters, context, feedback):
try:
# read out parameters
input_layer = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
in_crs = input_layer.crs()
attribute_name = parameters[self.ATTRIBUTE_NAME]
coverage_id = [
self.coverages[i] for i in self.parameterAsEnums(
parameters, self.COVERAGE_ID, context)
][0]
# start processing
fields = input_layer.fields()
fields.append(QgsField(attribute_name, QVariant.Double))
field_names = [field.name() for field in fields]
(sink, dest_id) = self.parameterAsSink(
parameters,
self.OUTPUT,
context,
fields,
input_layer.wkbType(),
in_crs,
)
if feedback.isCanceled():
return {}
wcs_proj_authid = self.get_native_proj_authid(coverage_id)
if in_crs.authid() != wcs_proj_authid:
wcs_crs = QgsCoordinateReferenceSystem(wcs_proj_authid)
transform_input = QgsCoordinateTransform(
in_crs, wcs_crs, QgsProject.instance())
for feature in input_layer.getFeatures():
geom = feature.geometry()
if in_crs.authid() != wcs_proj_authid:
geom.transform(transform_input)
point_geom = QgsGeometry.asPoint(geom)
point_xy = QgsPointXY(point_geom)
x = point_xy.x()
y = point_xy.y()
attrs = feature.attributes()
new_ft = QgsFeature(fields)
for i in range(len(attrs)):
attr = attrs[i]
field_name = field_names[i]
new_ft.setAttribute(field_name, attr)
ds = self.get_gdal_ds_from_wcs(x, y, coverage_id, feedback)
nodata = self.get_nodata_from_gdal_ds(ds)
ahn_val = self.get_val_from_gdal_ds(x, y, ds)
ds = None
if ahn_val == nodata:
fid = feature.id()
feedback.pushWarning(
f"NODATA value found for feature with id: {fid}, geom: POINT({x},{y})"
)
ahn_val = None
new_ft.setAttribute(attribute_name, ahn_val)
new_ft.setGeometry(geom)
sink.addFeature(new_ft, QgsFeatureSink.FastInsert)
if feedback.isCanceled():
return {}
results = {}
results[self.OUTPUT] = dest_id
return results
except Exception as e:
traceback_str = traceback.format_exc()
toolname = self.displayName()
message = f"Unexpected error occured while running {toolname}: {e} - traceback: {traceback_str}"
self.log_message(message, loglevel=2)
raise QgsProcessingException(message)
def traf(self, geometry, trafic, spatial, lines, echelle, angle_max,
dist_min, double_sens):
lignes = lines
conn = db.connect(':memory:')
conn.enable_load_extension(True)
conn.execute("select load_extension('mod_spatialite')")
c = conn.cursor()
proj = str(self.lines.crs().postgisSrid())
t = geometry[trafic]
texte = "select astext(st_buffer(st_geomfromtext('" + geometry.geometry(
).asWkt() + "'," + proj + ")," + str(echelle * t) + "))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
texte_buf = resultat[0][0]
texte_buf = texte_buf.replace("Polygon", "MultiLineString")
buf = QgsGeometry.fromWkt(texte_buf)
#buf=buf.convertToType(QgsWkbTypes.LineGeometry,False)
texte = "select astext(st_union(st_exteriorring(st_geomfromtext('" + buf.asWkt(
) + "'," + proj + "))))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf = QgsGeometry.fromWkt(resultat[0][0])
#QgsMessageLog.logMessage(texte)
#QgsMessageLog.logMessage(buf.asWkt())
buf_poly = buf
geom = geometry.geometry()
buf_sav = buf
buf_l = buf.length()
l2 = QgsLineString()
#print(geom.asWkt())
geom.convertToSingleType()
#print(geom.asWkt())
l2.fromWkt(geom.asWkt())
#print(l2.asWkt())
pt1 = QgsGeometry(l2.startPoint())
pt2 = QgsGeometry(l2.endPoint())
###point debut
debut = spatial.intersects(
QgsGeometry.buffer(pt1, 10, 3).boundingBox())
fe = [f for f in debut]
feats = []
for f in fe:
ff = QgsLineString()
#QgsMessageLog.logMessage(lignes[f].geometry().asWkt())
geom = lignes[f].geometry()
geom.convertToSingleType()
ff.fromWkt(geom.asWkt())
#QgsMessageLog.logMessage(ff.asWkt())
#print(pt1.distance(QgsGeometry(ff.startPoint())))
if pt1.distance(QgsGeometry(ff.startPoint())) < 10:
if lignes[f] not in feats:
feats.append(f)
elif pt1.distance(QgsGeometry(ff.endPoint())) < 10:
if lignes[f] not in feats:
feats.append(f)
#QgsMessageLog.logMessage(str(fe))
#QgsMessageLog.logMessage(str(feats))
distances = {}
angles = {}
for i in feats:
longueur = lignes[i].geometry().length()
if not (geometry.id() == i):
distances[i] = lignes[i].geometry().lineLocatePoint(pt1)
if distances[i] < dist_min:
angles[i] = ((lignes[i].geometry().interpolateAngle(
min(dist_min, longueur)) * 180 / math.pi) + 180) % 360
else:
angles[i] = lignes[i].geometry().interpolateAngle(
longueur - min(dist_min, longueur)) * 180 / math.pi
else:
angle1 = lignes[i].geometry().interpolateAngle(
min(dist_min, longueur)) * 180 / math.pi
angle_maxi = 1e38
voisin = None
angle_voisin = None
angle2 = None
if len(distances) == 0:
angle = (angle1) % 360
angle2 = angle1
angle_voisin = angle2
for i in distances:
if distances[i] < dist_min:
angle = (angles[i]) % 360
min_angle = min(
abs((angle + 180) % 360 - (angle1 + 180) % 360),
abs(angle - angle1))
if min_angle < angle_maxi:
angle_maxi = min_angle
angle_voisin = angle
voisin = i
else:
angle = angles[i]
min_angle = min(
abs((angle + 180) % 360 - (angle1 + 180) % 360),
abs(angle - angle1))
if min_angle < angle_maxi:
angle_maxi = min_angle
angle_voisin = angle
voisin = i
if min(abs((angle_voisin + 180) % 360 - (angle1 + 180) % 360),
abs(angle_voisin - angle1)) < angle_max:
if abs((angle_voisin + 180) % 360 -
(angle1 + 180) % 360) < abs(angle_voisin - angle1):
angle2 = (0.5 * (((angle_voisin + 180) % 360 +
(angle1 + 180) % 360)) + 180) % 360
else:
angle2 = 0.5 * (angle_voisin + angle1)
else:
angle2 = angle1
if angle2 == None:
angle2 = (angle1) % 360
start_line = QgsGeometry.fromPolyline([
QgsPoint(
pt1.asPoint().x() - 40 * echelle * t * math.cos(
(180 - angle2) * math.pi / 180),
pt1.asPoint().y() - 40 * echelle * t * math.sin(
(180 - angle2) * math.pi / 180)),
QgsPoint(pt1.asPoint().x(),
pt1.asPoint().y())
])
int1 = buf.intersection(start_line)
start_line2 = QgsGeometry.fromPolyline([
QgsPoint(
pt1.asPoint().x() + 40 * echelle * t * math.cos(
(180 - angle2) * math.pi / 180),
pt1.asPoint().y() + 40 * echelle * t * math.sin(
(180 - angle2) * math.pi / 180)),
QgsPoint(pt1.asPoint().x(),
pt1.asPoint().y())
])
int3 = buf.intersection(start_line2)
if int1.isMultipart():
points = int1.asMultiPoint()
dmax = 1e38
for p in points:
d = pt1.distance(QgsGeometry.fromPointXY(p))
if d < dmax:
dmax = d
pmax = p
int1 = QgsGeometry.fromPointXY(pmax)
if int3.isMultipart():
points = int3.asMultiPoint()
dmax = 1e38
for p in points:
d = pt1.distance(QgsGeometry.fromPointXY(p))
if d < dmax:
dmax = d
pmax = p
int3 = QgsGeometry.fromPointXY(pmax)
###point fin
debut = spatial.intersects(
QgsGeometry.buffer(pt2, 10, 3).boundingBox())
fe = [f for f in debut]
for f in fe:
ff = QgsLineString()
geom = lignes[f].geometry()
geom.convertToSingleType()
ff.fromWkt(geom.asWkt())
if pt2.distance(QgsGeometry(ff.startPoint())) < 10:
if lignes[f] not in feats:
feats.append(f)
elif pt2.distance(QgsGeometry(ff.endPoint())) < 10:
if lignes[f] not in feats:
feats.append(f)
distances = {}
angles = {}
for i in feats:
longueur = lignes[i].geometry().length()
if not (geometry.id() == i):
distances[i] = lignes[i].geometry().lineLocatePoint(pt2)
if distances[i] < dist_min:
angles[i] = (lignes[i].geometry().interpolateAngle(
min(dist_min, longueur)) * 180 / math.pi) % 360
else:
angles[i] = (((lignes[i].geometry().interpolateAngle(
longueur - min(dist_min, longueur)) * 180) / math.pi) +
180) % 360
else:
angle1 = ((lignes[i].geometry().interpolateAngle(
longueur - min(dist_min, longueur)) * 180 / math.pi))
angle_maxi = 1e38
voisin = None
angle_voisin = None
angle2 = None
if len(distances) == 0:
angle = (angle1) % 360
angle2 = angle1
angle_voisin = angle2
for i in distances:
if distances[i] < dist_min:
angle = (angles[i])
min_angle = min(
abs((angle + 180) % 360 - (angle1 + 180) % 360),
abs(angle - angle1))
if min_angle < angle_maxi:
angle_maxi = min_angle
angle_voisin = angle
voisin = i
else:
angle = (angles[i])
min_angle = min(
abs((angle + 180) % 360 - (angle1 + 180) % 360),
abs(angle - angle1))
if min_angle < angle_maxi:
angle_maxi = min_angle
angle_voisin = angle
voisin = i
if min(abs((angle_voisin + 180) % 360 - (angle1 + 180) % 360),
abs(angle_voisin - angle1)) < angle_max:
if abs((angle_voisin + 180) % 360 -
(angle1 + 180) % 360) < abs(angle_voisin - angle1):
angle2 = (0.5 * (((angle_voisin + 180) % 360 +
(angle1 + 180) % 360)) + 180) % 360
else:
angle2 = 0.5 * (angle_voisin + angle1)
else:
angle2 = angle1
if angle2 == None:
angle2 = (angle1) % 360
end_line = QgsGeometry.fromPolyline([
QgsPoint(
pt2.asPoint().x() - 40 * echelle * t * math.cos(
(180 - angle2) * math.pi / 180),
pt2.asPoint().y() - 40 * echelle * t * math.sin(
(180 - angle2) * math.pi / 180)),
QgsPoint(pt2.asPoint().x(),
pt2.asPoint().y())
])
int2 = buf.intersection(end_line)
end_line2 = QgsGeometry.fromPolyline([
QgsPoint(
pt2.asPoint().x() + 40 * echelle * t * math.cos(
(180 - angle2) * math.pi / 180),
pt2.asPoint().y() + 40 * echelle * t * math.sin(
(180 - angle2) * math.pi / 180)),
QgsPoint(pt2.asPoint().x(),
pt2.asPoint().y())
])
int4 = buf.intersection(end_line2)
int5 = start_line.intersection(end_line)
int6 = start_line2.intersection(end_line2)
m5 = -1
m6 = -1
if int5.type() == 0:
if int5.within(buf_poly):
m5 = 1
if int6.type() == 0:
if int6.within(buf_poly):
m6 = 1
if int2.isMultipart():
points = int2.asMultiPoint()
dmax = 1e38
for p in points:
d = pt2.distance(QgsGeometry.fromPointXY(p))
if d < dmax:
dmax = d
pmax = p
int2 = QgsGeometry.fromPointXY(pmax)
if int4.isMultipart():
points = int4.asMultiPoint()
dmax = 1e38
for p in points:
d = pt2.distance(QgsGeometry.fromPointXY(p))
if d < dmax:
dmax = d
pmax = p
int4 = QgsGeometry.fromPointXY(pmax)
#print(int1.exportToWkt(),int2.exportToWkt(),int3.exportToWkt(),int4.exportToWkt())
#QgsMessageLog.logMessage(buf.asWkt())
texte = "select astext(st_union(st_snap(st_geomfromtext('" + buf.asWkt(
) + "'," + proj + "),st_geomfromtext('" + int1.asWkt(
) + "'," + proj + "),1)))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf = resultat[0][0]
#QgsMessageLog.logMessage(texte)
#QgsMessageLog.logMessage(buf)
#QgsMessageLog.logMessage(proj)
#QgsMessageLog.logMessage(int2.asWkt())
texte = "select astext(st_union(st_snap(st_geomfromtext('" + buf + "'," + proj + "),st_geomfromtext('" + int2.asWkt(
) + "'," + proj + "),1)))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf = resultat[0][0]
texte = "select astext(st_union(st_snap(st_geomfromtext('" + buf + "'," + proj + "),st_geomfromtext('" + int3.asWkt(
) + "'," + proj + "),1)))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf = resultat[0][0]
texte = "select astext(st_union(st_snap(st_geomfromtext('" + buf + "'," + proj + "),st_geomfromtext('" + int4.asWkt(
) + "'," + proj + "),1)))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf = QgsGeometry.fromWkt(resultat[0][0])
m1 = buf.lineLocatePoint(int1)
m2 = buf.lineLocatePoint(int2)
m3 = buf.lineLocatePoint(int3)
m4 = buf.lineLocatePoint(int4)
#creation epaisseur
buf_l = buf.length()
m1 = m1 / buf_l
m2 = m2 / buf_l
m3 = m3 / buf_l
m4 = m4 / buf_l
if m2 < m1:
texte = "select asText(st_line_substring(st_geomfromtext('" + buf.asWkt(
) + "'," + proj + ")" + ',' + str(m2) + ',' + str(m1) + "))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf1 = QgsGeometry.fromWkt(resultat[0][0])
else:
texte = "select astext(st_union(st_snap(st_line_substring(geomfromtext('" + buf.asWkt(
) + "'," + proj + "),0," + str(
m1) + "),st_line_substring(geomfromtext('" + buf.asWkt(
) + "'," + proj + ")," + str(
m3
) + ",1),1),st_line_substring(geomfromtext('" + buf.asWkt(
) + "'," + proj + ")," + str(m2) + ",1)))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf1 = QgsGeometry.fromWkt(resultat[0][0])
if m3 < m4:
texte = "select asText(st_line_substring(st_geomfromtext('" + buf.asWkt(
) + "'," + proj + ")" + ',' + str(m3) + ',' + str(m4) + "))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf2 = QgsGeometry.fromWkt(resultat[0][0])
else:
texte = "select astext(st_union(g)) from (select st_line_substring(st_geomfromtext('" + buf.asWkt(
) + "'," + proj + "),0," + str(
m4
) + ") as \"g\" union all select st_line_substring(st_geomfromtext('" + buf.asWkt(
) + "'," + proj + ")," + str(m3) + ",1) as \"g\" )"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf2 = QgsGeometry.fromWkt(resultat[0][0])
texte = "select astext(st_union(st_snap(st_line_substring(geomfromtext('" + buf.asWkt(
) + "'," + proj + "),0," + str(
m4) + "),st_line_substring(geomfromtext('" + buf.asWkt(
) + "'," + proj + ")," + str(
m3
) + ",1),1),st_line_substring(geomfromtext('" + buf.asWkt(
) + "'," + proj + ")," + str(m3) + ",1)))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf2 = QgsGeometry.fromWkt(resultat[0][0])
g1 = buf
g2 = buf.shortestLine(int1)
g2 = g2.combine(g1)
g3 = buf.shortestLine(int2)
g3 = g3.combine(g2)
g3 = g3.combine(pt1.shortestLine(int1))
g3 = g3.combine(pt2.shortestLine(int2))
g3 = g3.combine(pt1.shortestLine(geometry.geometry()))
g3 = g3.combine(pt2.shortestLine(geometry.geometry()))
g3 = g3.combine(geometry.geometry())
buf3 = buf1.asWkt()
buf4 = buf2.asWkt()
if double_sens == False:
if m5 > 0:
texte = "select astext(st_union(st_snap(geomfromtext('" + geometry.geometry(
).asWkt(
) + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
int5).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
int5).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
int5).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
int5).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
else:
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf1.shortestLine(
int1
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + buf1.shortestLine(
int1).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf1.shortestLine(
int2
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + buf1.shortestLine(
int2).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
int1).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
int1).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
int2).asWkt() + "'),1),geomfromtext('" + pt2.shortestLine(
int2).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
geometry.geometry()).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
geometry.geometry()).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
geometry.geometry()).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
geometry.geometry()).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + geometry.geometry(
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + geometry.geometry(
).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
else:
if m5 > 0:
texte = "select astext(st_union(st_snap(geomfromtext('" + buf4 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
int3).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
int3).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
int4).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
int4).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
int5).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
int5).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
int5).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
int5).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
elif m6 > 0:
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
int1).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
int1).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
int2).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
int2).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt1.shortestLine(
int6).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt1.shortestLine(
int6).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + pt2.shortestLine(
int6).asWkt(
) + "'," + proj + "),1),geomfromtext('" + pt2.shortestLine(
int6).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
else:
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf1.shortestLine(
int1
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + buf1.shortestLine(
int1).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf1.shortestLine(
int2
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + buf1.shortestLine(
int2).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + int3.shortestLine(
int1
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + int3.shortestLine(
int1).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + int4.shortestLine(
int2
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + int4.shortestLine(
int2).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf2.shortestLine(
int3
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + buf2.shortestLine(
int3).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf2.shortestLine(
int4
).asWkt(
) + "'," + proj + "),1),geomfromtext('" + buf2.shortestLine(
int4).asWkt() + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_union(st_snap(geomfromtext('" + buf3 + "'," + proj + "),geomfromtext('" + buf4 + "'," + proj + "),1),geomfromtext('" + buf4 + "'," + proj + ")))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf3 = resultat[0][0]
texte = "select astext(st_buildarea(st_union(g))) from ((select geomfromtext('" + buf3 + "'," + proj + ") as \"g\"))"
rs = c.execute(texte)
resultat = c.fetchall()
conn.commit()
buf = QgsGeometry.fromWkt(resultat[0][0])
return (buf)
class GeometryHighlight(QgsMapCanvasItem):
_mapCanvas = None # QgsMapCanvas
_geometry = None # QgsGeometry()
_brush = QBrush()
_pen = QPen()
def __init__(self, mapCanvas, geometry, layer):
super(GeometryHighlight, self).__init__(mapCanvas)
self._mapCanvas = mapCanvas
if not geometry or not isinstance(geometry, QgsGeometry) or geometry.isEmpty() or not geometry.isGeosValid():
return
self._geometry = QgsGeometry(geometry) # Force deep copy
self.setLineColor(Project.highlightLineColor())
self.setFillColor(Project.highlightFillColor())
if (layer and self._mapCanvas.mapSettings().hasCrsTransformEnabled()):
ct = self._mapCanvas.mapSettings().layerTransform(layer)
if ct:
self._geometry.transform(ct)
self.updateRect()
self.update()
def remove(self):
self._mapCanvas.scene().removeItem(self)
def setLineWidth(self, width):
self._pen.setWidth(width)
def setLineColor(self, color):
lineColor = QColor(color)
lineColor.setAlpha(255)
self._pen.setColor(lineColor)
def setFillColor(self, fillColor):
self._brush.setColor(fillColor)
self._brush.setStyle(Qt.SolidPattern)
def updatePosition(self):
pass
# protected:
def paint(self, painter, option=None, widget=None): # Override
if not self._geometry:
return
painter.setPen(self._pen)
painter.setBrush(self._brush)
wkbType = self._geometry.wkbType()
if wkbType == QGis.WKBPoint or wkbType == QGis.WKBPoint25D:
self._paintPoint(painter, self._geometry.asPoint())
elif wkbType == QGis.WKBMultiPoint or wkbType == QGis.WKBMultiPoint25D:
for point in self._geometry.asMultiPoint():
self._paintPoint(painter, point)
elif wkbType == QGis.WKBLineString or wkbType == QGis.WKBLineString25D:
self._paintLine(painter, self._geometry.asPolyline())
elif wkbType == QGis.WKBMultiLineString or wkbType == QGis.WKBMultiLineString25D:
for line in self._geometry.asMultiPolyline():
self._paintLine(painter, line)
elif wkbType == QGis.WKBPolygon or wkbType == QGis.WKBPolygon25D:
self._paintPolygon(painter, self._geometry.asPolygon())
elif wkbType == QGis.WKBMultiPolygon or wkbType == QGis.WKBMultiPolygon25D:
for polygon in self._geometry.asMultiPolygon():
self._paintPolygon(painter, polygon)
def updateRect(self):
if self._geometry:
r = self._geometry.boundingBox()
if r.isEmpty():
d = self._mapCanvas.extent().width() * 0.005
r.setXMinimum(r.xMinimum() - d)
r.setYMinimum(r.yMinimum() - d)
r.setXMaximum(r.xMaximum() + d)
r.setYMaximum(r.yMaximum() + d)
self.setRect(r)
self.setVisible(True)
else:
self.setRect(QgsRectangle())
# private:
def _paintPoint(self, painter, point):
painter.drawEllipse(self.toCanvasCoordinates(point) - self.pos(), 2, 2)
def _paintLine(self, painter, line):
polyline = QPolygonF()
for point in line:
polyline.append(self.toCanvasCoordinates(point) - self.pos())
painter.drawPolyline(polyline)
def _paintPolygon(self, painter, polygon):
path = QPainterPath()
for line in polygon:
ring = QPolygonF()
for point in line:
cur = self.toCanvasCoordinates(point) - self.pos()
ring.append(cur)
ring.append(ring[0])
path.addPolygon(ring)
painter.drawPath(path)
def doWork(self):
#Defining layer type
for testLayer in self.iface.mapCanvas().layers():
if testLayer.type() == QgsMapLayer.VectorLayer:
workFeature = list(testLayer.getSelectedFeatures())
workCrs = testLayer.crs()
if not workFeature:
QMessageBox.critical(self, u"Erro", u"Nenhuma feição selecionada. Selecione ao menos uma feição vetorial.")
return
workGeometries = []
for i in range(len(workFeature)):
workGeometries.append(workFeature[i].geometry())
centr = QgsGeometry().collectGeometry(workGeometries).centroid()
listElem = QgsFeature()
listElem.setGeometry(centr)
centrList = []
centrList.append(listElem)
centr = centr.asPoint()
#Opening UTM Zones layer and finding intersections
utmZone = DimensionsVFDialog(self.iface).UTMcheck(centrList, workCrs)[0]
decl = GeoMag().GeoMag(centr.y(), centr.x()).dec
conv = DeclConvDockWidget(self.iface).calcConvergence(centr)
if not utmZone:
QMessageBox.critical(self, u"Erro", u"Feição selecionada fora do Brasil. Escolha uma feição dentro.")
return
pontos = {}
pointList=[]
for f in workGeometries:
for i in f.vertices():
pointList.append(i)
pontos[f] = pointList
pointList=[]
pontos_conv = {}
pointList=[]
zoneDict = {'18S':31978,'19N':31973, '19S':31979, '20N':31974, '20S':31980,'21N':31975, '21S':31981, '22N':31976, '22S':31982, '23S':31983, '24S':31984, '25S':31985, '26S':31986}
transformer = QgsCoordinateTransform(workCrs, QgsCoordinateReferenceSystem(zoneDict[utmZone[0]], QgsCoordinateReferenceSystem.EpsgCrsId), QgsProject.instance())
for f in workGeometries:
for i in range(len(list(f.vertices()))):
pointList.append(pontos[f][i])
pointList[i].transform(transformer)
pontos_conv[f] = pointList
pointList=[]
self.convEdit.setText(str(conv))
self.declEdit.setText(str(decl))
self.final_list = []
ponto_inicial = pontos[0]
for idx in range(0,len(pontos)-1):
pt1 = pontos_conv[idx]
pt2 = pontos_conv[idx+1]
crs1 = pontos[idx][1]
azim = pt1.azimuth(pt2) - decl
if azim < 0:
azim = azim + 360
d = QgsDistanceArea()
dist = format( d.measureLine(pt1,pt2), '.3f' )
#VERIFICAR UNIDADES DO MAPA
if crs1.mapUnits in [QGis.Degrees, QGis.DecimalDegrees]:
#GERAR GRAU, MINUTOS E SEGUNDOS PARA X E Y
x = self.gerarGMS( pontos[idx][0].x() )
y = self.gerarGMS( pontos[idx][0].y() )
else:
x = str( pontos[idx][0].x() )
y = str( pontos[idx][0].y() )
a = self.gerarGMS( azim )
am = format( self.converterParaMilesimos( azim - decl ), '.3f' )
self.final_list.append( (x, y, a, am, dist, crs1) )
ponto_final = pontos_conv[len(pontos)-1]
crsFinal = pontos[len(pontos)-1][1]
x = self.gerarGMS( pontos[len(pontos)-1][0].x() ) if crsFinal.mapUnits() in [QGis.Degrees, QGis.DecimalDegrees] else str( pontos[len(pontos)-1][0].x() )
y = self.gerarGMS( pontos[len(pontos)-1][0].y() ) if crsFinal.mapUnits() in [QGis.Degrees, QGis.DecimalDegrees] else str( pontos[len(pontos)-1][0].y() )
self.final_list.append( (x, y, u"Final", u"Final", u"Final") )
#CRIAR A TABELA DA INTERFACE
self.exportDialog.fillTable(self.final_list, decl, conv, ponto_inicial)
def getPixelValueFromPoint(self, mousePosGeom, rasterLayer, fromCanvas = True):
"""
"""
rasterCrs = rasterLayer.crs() if rasterLayer else False
if rasterCrs:
if fromCanvas:
self.dsgGeometryHandler.reprojectFeature(mousePosGeom, rasterCrs, self.canvas.mapRenderer().destinationCrs())
else:
mousePosGeom = QgsGeometry(mousePosGeom)
self.dsgGeometryHandler.reprojectFeature(mousePosGeom, rasterCrs, self.canvas.currentLayer().crs())
# isMulti = QgsWKBTypes.isMultiType(int(layer.wkbType())) # tem que ver se serve pra QgsGeometry
mousePos = mousePosGeom.asMultiPoint()[0] if mousePosGeom.isMultipart() else mousePosGeom.asPoint()
# identify pixel(s) information
i = rasterLayer.dataProvider().identify( mousePos, QgsRaster.IdentifyFormatValue )
if i.isValid():
value = i.results().values()[0]
if value:
value = int(value) if self.decimals == 0 else round(value, self.decimals)
return value
else:
return None
def draw(self, rows, con, args, geomType, canvasItemList, mapCanvas):
''' draw the result '''
resultPathsRubberBands = canvasItemList['paths']
rubberBand = None
cur_path_id = -1
for row in rows:
cur2 = con.cursor()
args['result_path_id'] = row[0]
args['result_source_id'] = row[1]
args['result_target_id'] = row[2]
args['result_cost'] = row[3]
if args['result_path_id'] != cur_path_id:
cur_path_id = args['result_path_id']
if rubberBand:
resultPathsRubberBands.append(rubberBand)
rubberBand = None
rubberBand = QgsRubberBand(mapCanvas,
Utils.getRubberBandType(False))
rubberBand.setColor(QColor(255, 0, 0, 128))
rubberBand.setWidth(4)
if args['result_cost'] != -1:
query2 = """
SELECT ST_AsText( ST_MakeLine(
(SELECT the_geom FROM %(edge_table)s_vertices_pgr WHERE id = %(result_source_id)d),
(SELECT the_geom FROM %(edge_table)s_vertices_pgr WHERE id = %(result_target_id)d)
))
""" % args
##Utils.logMessage(query2)
cur2.execute(query2)
row2 = cur2.fetchone()
##Utils.logMessage(str(row2[0]))
assert row2, "Invalid result geometry. (path_id:%(result_path_id)d, saource_id:%(result_source_id)d, target_id:%(result_target_id)d)" % args
geom = QgsGeometry().fromWkt(str(row2[0]))
if geom.wkbType() == QgsWkbTypes.MultiLineString:
for line in geom.asMultiPolyline():
for pt in line:
rubberBand.addPoint(pt)
elif geom.wkbType() == QgsWkbTypes.LineString:
for pt in geom.asPolyline():
rubberBand.addPoint(pt)
if rubberBand:
resultPathsRubberBands.append(rubberBand)
rubberBand = None
resultNodesTextAnnotations = canvasItemList['annotations']
Utils.setStartPoint(geomType, args)
Utils.setEndPoint(geomType, args)
for row in rows:
cur2 = con.cursor()
args['result_seq'] = row[0]
args['result_source_id'] = row[1]
args['result_target_id'] = row[2]
args['result_cost'] = row[3]
query2 = """
SELECT ST_AsText(%(transform_s)s%(startpoint)s%(transform_e)s) FROM %(edge_table)s
WHERE %(source)s = %(result_target_id)d
UNION
SELECT ST_AsText(%(transform_s)s%(endpoint)s%(transform_e)s) FROM %(edge_table)s
WHERE %(target)s = %(result_target_id)d
""" % args
cur2.execute(query2)
row2 = cur2.fetchone()
assert row2, "Invalid result geometry. (target_id:%(result_target_id)d)" % args
geom = QgsGeometry().fromWkt(str(row2[0]))
pt = geom.asPoint()
textDocument = QTextDocument(
"%(result_target_id)d:%(result_cost)f" % args)
textAnnotation = QgsTextAnnotation()
textAnnotation.setMapPosition(geom.asPoint())
textAnnotation.setFrameSize(QSizeF(textDocument.idealWidth(), 20))
textAnnotation.setFrameOffsetFromReferencePoint(QPointF(20, -40))
textAnnotation.setDocument(textDocument)
QgsMapCanvasAnnotationItem(textAnnotation, mapCanvas)
resultNodesTextAnnotations.append(textAnnotation)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
fields = [QgsField('POINTA', QVariant.Double, '', 24, 15),
QgsField('POINTB', QVariant.Double, '', 24, 15),
QgsField('POINTC', QVariant.Double, '', 24, 15)]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields,
QgsWkbTypes.Polygon, layer.crs())
pts = []
ptDict = {}
ptNdx = -1
c = voronoi.Context()
features = vector.features(layer)
total = 100.0 / len(features)
for current, inFeat in enumerate(features):
geom = QgsGeometry(inFeat.geometry())
if geom.isEmpty():
continue
if geom.isMultipart():
points = geom.asMultiPoint()
else:
points = [geom.asPoint()]
for n, point in enumerate(points):
x = point.x()
y = point.y()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = (inFeat.id(), n)
progress.setPercentage(int(current * total))
if len(pts) < 3:
raise GeoAlgorithmExecutionException(
self.tr('Input file should contain at least 3 points. Choose '
'another file and try again.'))
uniqueSet = set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(*i) for i in uniqueSet])
c.triangulate = True
voronoi.voronoi(sl, c)
triangles = c.triangles
feat = QgsFeature()
total = 100.0 / len(triangles)
for current, triangle in enumerate(triangles):
indicies = list(triangle)
indicies.append(indicies[0])
polygon = []
attrs = []
step = 0
for index in indicies:
fid, n = ptDict[ids[index]]
request = QgsFeatureRequest().setFilterFid(fid)
inFeat = next(layer.getFeatures(request))
geom = QgsGeometry(inFeat.geometry())
if geom.isMultipart():
point = QgsPoint(geom.asMultiPoint()[n])
else:
point = QgsPoint(geom.asPoint())
polygon.append(point)
if step <= 3:
attrs.append(ids[index])
step += 1
feat.setAttributes(attrs)
geometry = QgsGeometry().fromPolygon([polygon])
feat.setGeometry(geometry)
writer.addFeature(feat)
progress.setPercentage(int(current * total))
del writer
def delaunay_triangulation( self ):
import voronoi
from sets import Set
vprovider = self.vlayer.dataProvider()
fields = QgsFields()
fields.append( QgsField( "POINTA", QVariant.Double ) )
fields.append( QgsField( "POINTB", QVariant.Double ) )
fields.append( QgsField( "POINTC", QVariant.Double ) )
writer = QgsVectorFileWriter( self.myName, self.myEncoding, fields,
QGis.WKBPolygon, vprovider.crs() )
inFeat = QgsFeature()
c = voronoi.Context()
pts = []
ptDict = {}
ptNdx = -1
fit = vprovider.getFeatures()
while fit.nextFeature( inFeat ):
geom = QgsGeometry( inFeat.geometry() )
point = geom.asPoint()
x = point.x()
y = point.y()
pts.append( ( x, y ) )
ptNdx +=1
ptDict[ptNdx] = inFeat.id()
if len(pts) < 3:
return False
uniqueSet = Set( item for item in pts )
ids = [ pts.index( item ) for item in uniqueSet ]
sl = voronoi.SiteList( [ voronoi.Site( *i ) for i in uniqueSet ] )
c.triangulate = True
voronoi.voronoi( sl, c )
triangles = c.triangles
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 = []
attrs = []
step = 0
for index in indicies:
vprovider.getFeatures( QgsFeatureRequest().setFilterFid( ptDict[ ids[ index ] ] ) ).nextFeature( inFeat )
geom = QgsGeometry( inFeat.geometry() )
point = QgsPoint( geom.asPoint() )
polygon.append( point )
if step <= 3:
attrs.append(ids[ index ] )
step += 1
feat.setAttributes(attrs)
geometry = QgsGeometry().fromPolygon( [ polygon ] )
feat.setGeometry( geometry )
writer.addFeature( feat )
nElement += 1
self.emit( SIGNAL( "runStatus( PyQt_PyObject )" ), nElement )
del writer
return True
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(self.getParameterValue(
self.INPUT))
fields = [
QgsField('POINTA', QVariant.Double, '', 24, 15),
QgsField('POINTB', QVariant.Double, '', 24, 15),
QgsField('POINTC', QVariant.Double, '', 24, 15)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Polygon, layer.crs())
pts = []
ptDict = {}
ptNdx = -1
c = voronoi.Context()
features = vector.features(layer)
total = 100.0 / len(features)
for current, inFeat in enumerate(features):
geom = QgsGeometry(inFeat.geometry())
if geom.isNull():
continue
if geom.isMultipart():
points = geom.asMultiPoint()
else:
points = [geom.asPoint()]
for n, point in enumerate(points):
x = point.x()
y = point.y()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = (inFeat.id(), n)
feedback.setProgress(int(current * total))
if len(pts) < 3:
raise GeoAlgorithmExecutionException(
self.tr('Input file should contain at least 3 points. Choose '
'another file and try again.'))
uniqueSet = set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(*i) for i in uniqueSet])
c.triangulate = True
voronoi.voronoi(sl, c)
triangles = c.triangles
feat = QgsFeature()
total = 100.0 / len(triangles)
for current, triangle in enumerate(triangles):
indices = list(triangle)
indices.append(indices[0])
polygon = []
attrs = []
step = 0
for index in indices:
fid, n = ptDict[ids[index]]
request = QgsFeatureRequest().setFilterFid(fid)
inFeat = next(layer.getFeatures(request))
geom = QgsGeometry(inFeat.geometry())
if geom.isMultipart():
point = QgsPoint(geom.asMultiPoint()[n])
else:
point = QgsPoint(geom.asPoint())
polygon.append(point)
if step <= 3:
attrs.append(ids[index])
step += 1
feat.setAttributes(attrs)
geometry = QgsGeometry().fromPolygon([polygon])
feat.setGeometry(geometry)
writer.addFeature(feat)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(
self.INPUT))
fields = [
QgsField('POINTA', QVariant.Double, '', 24, 15),
QgsField('POINTB', QVariant.Double, '', 24, 15),
QgsField('POINTC', QVariant.Double, '', 24, 15)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QGis.WKBPolygon, layer.crs())
pts = []
ptDict = {}
ptNdx = -1
c = voronoi.Context()
features = vector.features(layer)
for inFeat in features:
geom = QgsGeometry(inFeat.geometry())
point = geom.asPoint()
x = point.x()
y = point.y()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = inFeat.id()
if len(pts) < 3:
raise GeoAlgorithmExecutionException(
self.tr('Input file should contain at least 3 points. Choose '
'another file and try again.'))
uniqueSet = Set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(*i) for i in uniqueSet])
c.triangulate = True
voronoi.voronoi(sl, c)
triangles = c.triangles
feat = QgsFeature()
current = 0
total = 100.0 / float(len(triangles))
for triangle in triangles:
indicies = list(triangle)
indicies.append(indicies[0])
polygon = []
attrs = []
step = 0
for index in indicies:
request = QgsFeatureRequest().setFilterFid(ptDict[ids[index]])
inFeat = layer.getFeatures(request).next()
geom = QgsGeometry(inFeat.geometry())
point = QgsPoint(geom.asPoint())
polygon.append(point)
if step <= 3:
attrs.append(ids[index])
step += 1
feat.setAttributes(attrs)
geometry = QgsGeometry().fromPolygon([polygon])
feat.setGeometry(geometry)
writer.addFeature(feat)
current += 1
progress.setPercentage(int(current * total))
del writer
def generateFootprintsForFilmVertical(self):
self.reloadFpLayer()
self.reloadCpLayer()
# Error wenn nur ein punkt vorhanden
if self.cpLayer.featureCount() > 1:
caps = self.fpLayer.dataProvider().capabilities()
if caps & QgsVectorDataProvider.AddFeatures:
#Get FORM1 from FilmInfoDict
f1 = self.currentFilmInfoDict["form1"] # Image height
f2 = self.currentFilmInfoDict["form2"] # Image width
iterFeatures = self.cpLayer.getFeatures()
iterNext = self.cpLayer.getFeatures()
existingFootpints = QgsVectorLayerUtils.getValues(
self.fpLayer, "bildnummer")[0]
ft = QgsFeature()
ftNext = QgsFeature()
iterNext.nextFeature(ftNext)
fpFeats = []
kappasToUpdate = {}
# iterate over points from CP Layer > LON, LAT
i = 0
while iterFeatures.nextFeature(ft):
i += 1
iterNext.nextFeature(ftNext)
p = QgsPointXY(ft.geometry().asPoint())
if ft['bildnummer'] in existingFootpints:
pPrevGeom = QgsGeometry(ft.geometry())
#QMessageBox.warning(None, u"Bild Nummern", u"Footprint für das Bild mit der Nummer {0} wurde bereits erstellt.".format(ft['BILD']))
continue
if i == 1:
pPrevGeom = QgsGeometry(ftNext.geometry())
#if iterNext.isClosed():
# #use pPrev as pNext
# pNext = QgsPoint(pPrev)
#else:
# pNext = QgsPoint(ftNext.geometry().asPoint())
#kappa = p.azimuth(pPrev)
#kappa = p.azimuth(pNext)
# d = math.sqrt(2*((f1/2 * ft['MASS']/1000)**2))
d1 = f1 / 2 * ft['massstab'] / 1000
d2 = f2 / 2 * ft['massstab'] / 1000
#QMessageBox.warning(None, u"Bild Nummern", "{0}".format(d))
calcCrs = QgsCoordinateReferenceSystem()
calcCrs.createFromProj4(self.Proj4Utm(p))
ctF = QgsCoordinateTransform(self.cpLayer.crs(), calcCrs,
QgsProject.instance())
cpMetric = QgsGeometry(ft.geometry())
cpMetric.transform(ctF)
pPrevGeom.transform(ctF)
pMetric = QgsPointXY(cpMetric.asPoint())
pPrevMetric = QgsPointXY(pPrevGeom.asPoint())
kappaMetric = pMetric.azimuth(pPrevMetric)
pPrevGeom = QgsGeometry(ft.geometry())
left = pMetric.x() - d2
bottom = pMetric.y() - d1
right = pMetric.x() + d2
top = pMetric.y() + d1
#R = 6371
#D = (d/1000)
#cpLat = math.radians(p.y())
#cpLon = math.radians(p.x())
#urLat = math.asin( math.sin(cpLat)*math.cos(D/R) + math.cos(cpLat)*math.sin(D/R)*math.cos(urBrng) )
#urLon = cpLon + math.atan2(math.sin(urBrng)*math.sin(D/R)*math.cos(cpLat), math.cos(D/R)-math.sin(cpLat)*math.sin(urLat))
#top = math.asin( math.sin(cpLat)*math.cos(D/R) + math.cos(cpLat)*math.sin(D/R) )
#bottom = math.asin( math.sin(cpLat)*math.cos(D/R) + math.cos(cpLat)*math.sin(D/R)*-1 )
#lat = math.asin( math.sin(cpLat)*math.cos(D/R) )
#right = cpLon + math.atan2(math.sin(D/R)*math.cos(cpLat), math.cos(D/R)-math.sin(cpLat)*math.sin(lat))
#left = cpLon + math.atan2(-1*math.sin(D/R)*math.cos(cpLat), math.cos(D/R)-math.sin(cpLat)*math.sin(lat))
#QMessageBox.warning(None, u"Bild Nummern", "{0}, {1}, {2}, {3}".format(math.degrees(top), math.degrees(bottom), math.degrees(left), math.degrees(right)))
#rect = QgsRectangle(math.degrees(left), math.degrees(bottom), math.degrees(right), math.degrees(top))
#l = math.degrees(left)
#b = math.degrees(bottom)
#r = math.degrees(right)
#t = math.degrees(top)
p1 = QgsGeometry.fromPointXY(QgsPointXY(left, bottom))
p2 = QgsGeometry.fromPointXY(QgsPointXY(right, bottom))
p3 = QgsGeometry.fromPointXY(QgsPointXY(right, top))
p4 = QgsGeometry.fromPointXY(QgsPointXY(left, top))
#p1.rotate(kappa+90, p)
#p2.rotate(kappa+90, p)
#p3.rotate(kappa+90, p)
#p4.rotate(kappa+90, p)
pol = [[
p1.asPoint(),
p2.asPoint(),
p3.asPoint(),
p4.asPoint()
]]
geom = QgsGeometry.fromPolygonXY(pol)
geom.rotate(kappaMetric, pMetric)
#Transform to DestinationCRS
ctB = QgsCoordinateTransform(calcCrs, self.fpLayer.crs(),
QgsProject.instance())
geom.transform(ctB)
feat = QgsFeature(self.fpLayer.fields())
feat.setGeometry(geom)
feat.setAttribute('filmnummer', self.currentFilmNumber)
feat.setAttribute('bildnummer', ft['bildnummer'])
da = QgsDistanceArea()
da.setEllipsoid(self.fpLayer.crs().ellipsoidAcronym())
feat.setAttribute('shape_length',
da.measurePerimeter(geom))
feat.setAttribute('shape_area', da.measureArea(geom))
fpFeats.append(feat)
# update Kappa in cpLayer
kappasToUpdate[ft.id()] = {
ft.fieldNameIndex('kappa'): kappaMetric
}
iterFeatures.close()
iterNext.close()
resCAVs = self.cpLayer.dataProvider().changeAttributeValues(
kappasToUpdate)
QgsMessageLog.logMessage(
f"Kappa Update for {kappasToUpdate}, Success: {resCAVs}",
tag="APIS",
level=Qgis.Success if resCAVs else Qgis.Critical)
(res,
outFeats) = self.fpLayer.dataProvider().addFeatures(fpFeats)
self.fpLayer.updateExtents()
if self.canvas.isCachingEnabled():
self.fpLayer.triggerRepaint()
else:
self.canvas.refresh()
else:
#Caps
QMessageBox.warning(None, "Layer Capabilities!",
"Layer Capabilities!")
else:
#small feature count
QMessageBox.warning(
None, "Footprints",
"Zum Berechnen der senkrecht Footprint müssen mindestens zwei Bilder kartiert werden!"
)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(
self.INPUT))
buf = self.getParameterValue(self.BUFFER)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.pendingFields().toList(), QGis.WKBPolygon, layer.crs())
outFeat = QgsFeature()
extent = layer.extent()
extraX = extent.height() * (buf / 100.0)
extraY = extent.width() * (buf / 100.0)
height = extent.height()
width = extent.width()
c = voronoi.Context()
pts = []
ptDict = {}
ptNdx = -1
features = vector.features(layer)
total = 100.0 / len(features)
for current, inFeat in enumerate(features):
geom = QgsGeometry(inFeat.geometry())
point = geom.asPoint()
x = point.x() - extent.xMinimum()
y = point.y() - extent.yMinimum()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = inFeat.id()
progress.setPercentage(int(current * total))
if len(pts) < 3:
raise GeoAlgorithmExecutionException(
self.tr('Input file should contain at least 3 points. Choose '
'another file and try again.'))
uniqueSet = set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([
voronoi.Site(i[0], i[1], sitenum=j)
for (j, i) in enumerate(uniqueSet)
])
voronoi.voronoi(sl, c)
inFeat = QgsFeature()
current = 0
total = 100.0 / len(c.polygons)
for (site, edges) in c.polygons.iteritems():
request = QgsFeatureRequest().setFilterFid(ptDict[ids[site]])
inFeat = layer.getFeatures(request).next()
lines = self.clip_voronoi(edges, c, width, height, extent, extraX,
extraY)
geom = QgsGeometry.fromMultiPoint(lines)
geom = QgsGeometry(geom.convexHull())
outFeat.setGeometry(geom)
outFeat.setAttributes(inFeat.attributes())
writer.addFeature(outFeat)
current += 1
progress.setPercentage(int(current * total))
del writer
def load_complex_gml(self, xml_uri, is_remote, attributes = {}, geometry_mapping = None, logger = None, swap_xy = False):
"""
:param xml_uri: the XML URI
:param is_remote: True if it has to be fetched by http
:param attributes: { 'attr1' : ( '//xpath/expression', QVariant.Int ) }
:param geometry_mapping: XPath expression to a gml geometry node
:param swap_xy: True if X/Y coordinates must be swapped
:returns: the created layer
"""
if is_remote:
xml = remote_open_from_qgis(xml_uri)
else:
# Open the file in binary mode, this means returning bytes
# instead of a string whose encoding would have to be interpreted
# it is up to the XML parser to determine which encoding it is
xml = open(xml_uri, 'rb')
src = ComplexFeatureSource(xml, attributes, geometry_mapping, logger)
attr_list = [ (k, v[1]) for k, v in attributes.items() ]
# first feature
id, fid, g, xml, attrs = next(src.getFeatures())
qgsgeom = None
if g is None:
layer = self._create_layer('none', None, attr_list, src.title)
else:
wkb, srid = g
qgsgeom = QgsGeometry()
qgsgeom.fromWkb(wkb)
if qgsgeom and qgsgeom.type() == QgsWkbTypes.PointGeometry:
layer = self._create_layer('point', srid, attr_list, src.title + " (points)")
elif qgsgeom and qgsgeom.type() == QgsWkbTypes.LineGeometry:
layer = self._create_layer('linestring', srid, attr_list, src.title + " (lines)")
elif qgsgeom and qgsgeom.type() == QgsWkbTypes.PolygonGeometry:
layer = self._create_layer('polygon', srid, attr_list, src.title + " (polygons)")
# add metadata
self._add_properties_to_layer(layer, xml_uri, is_remote, attributes, geometry_mapping)
# collect features
features = []
for id, fid, g, xml, attrs in src.getFeatures():
qgsgeom = None
wkb, srid = g
qgsgeom = QgsGeometry()
qgsgeom.fromWkb(wkb)
if qgsgeom and qgsgeom.type() == QgsWkbTypes.PointGeometry:
if swap_xy:
p = qgsgeom.asPoint()
qgsgeom = QgsGeometry.fromPoint(QgsPointXY(p[1], p[0]))
elif qgsgeom and qgsgeom.type() == QgsWkbTypes.LineGeometry:
if swap_xy:
pl = qgsgeom.asPolyline()
qgsgeom = QgsGeometry.fromPolyline([QgsPointXY(p[1],p[0]) for p in pl])
elif qgsgeom and qgsgeom.type() == QgsWkbTypes.PolygonGeometry:
if swap_xy:
pl = qgsgeom.asPolygon()
qgsgeom = QgsGeometry.fromPolygon([[QgsPointXY(p[1],p[0]) for p in r] for r in pl])
f = QgsFeature(layer.dataProvider().fields(), id)
if qgsgeom:
f.setGeometry(qgsgeom)
f.setAttribute("id", str(id))
f.setAttribute("fid", fid)
f.setAttribute("_xml_", ET.tostring(xml).decode('utf8'))
for k, v in attrs.items():
r = f.setAttribute(k, v)
features.append(f)
# write features
if len(features) > 0:
layer.dataProvider().addFeatures(features)
return layer
def addZtoPointFeatures(self,
inputPoints,
inputCrs,
fieldIdWithZVals=-1,
override=True):
#pointsListZ=[] #list of QgsFeature()
featuresWithZ = []
try:
#check if pointsLayer is emty
#if inputPoints.featureCount!=0:
for feat in inputPoints:
#if geom.hasZ==False or geom.hasZ==True and override==True:
# get Raster Values for each point feature
featZ = QgsFeature(feat.fields()) #Copy of the Feature
geom = feat.geometry()
#create a copy of the geometry for temporary transform to the project.crs()
wkb = feat.geometry().asWkb()
#self.feedback.pushInfo("addZtoPointFeatures1 " + geom.asWkt())
geom2CRS = QgsGeometry()
geom2CRS.fromWkb(wkb)
#transform geom to rasterLayer.crs() if crs a different
if not inputCrs.authid() == self.rasterLayer.crs().authid():
trafo = QgsCoordinateTransform(inputCrs,
self.rasterLayer.crs(),
QgsProject.instance())
#transform clip Geom to SrcLayer.crs Reverse
geom2CRS.transform(trafo,
QgsCoordinateTransform.ForwardTransform,
False)
pinPoint = None
if geom.isMultipart():
pinPoint = geom.vertexAt(
0) #nimm den ersten Punkt, wenn es ein MultiPoint ist
pin2Crs = geom2CRS.vertexAt(0)
else:
pinPoint = geom.asPoint()
pin2Crs = geom2CRS.asPoint()
rastVal = None
if fieldIdWithZVals > -1:
rastVal = feat[fieldIdWithZVals]
if rastVal is None or str(rastVal) == 'NULL':
felder = feat.fields()
feld = felder.field(fieldIdWithZVals)
self.feedback.reportError('Error on Feature ' +
str(feat.id()))
self.feedback.reportError('Feature Attributes :' +
str(feat.attributes()))
raise QgsProcessingException('Z value on field ' +
feld.name() +
' is empty!')
else: #hole Z-Wert von DGM
rastVal = self.interpolator.linear(
pin2Crs) #QgsPointXY(4459566.0, 5613959.0))
#self.feedback.pushInfo("addZtoPointFeatures2 " + geom.asWkt() + " 2Crs: " + geom2CRS.asWkt())
#self.feedback.pushInfo("rastVal " + str(pinPoint)+ " = in RasterCrs:"+ str(pin2Crs)+ " = "+ str(rastVal))
#rastSample = rasterLayer.dataProvider().identify(pin2Crs, QgsRaster.IdentifyFormatValue).results()
if not rastVal is None or str(
rastVal
) != 'NULL': # ToDo der Leerwert muss noch beruecksichtigt werden
wkt = "PointZ(" + str(pinPoint.x()) + " " + str(
pinPoint.y()) + " " + str(rastVal) + ")"
#self.feedback.reportError(wkt)
#construct new Feature in source Crs
ptZ = QgsPoint(pinPoint.x(), pinPoint.y())
ptZ.addZValue(rastVal)
geomZ = QgsGeometry.fromWkt(wkt)
featZ.setGeometry(geomZ)
featZ.setAttributes(feat.attributes())
featuresWithZ.append(featZ)
else:
self.feedback.reportError('Point Feature: ' + feat.id() +
' ' + wkt + ' ' +
feat.attributes())
raise QgsProcessingException(
"No valid RasterValue for this position: " +
str(round(pinPoint.x(), 1)) + " " +
str(round(pinPoint.y(), 1)) + ' raster value: ' +
str(rastVal))
#self.feedback.pushInfo("addZtoPointFeatures " + str(len(featuresWithZ))+ " Objekte")
except Exception as err:
msg = "Error: add Z to Point Features {0} \n {1}".format(
err.args, repr(err))
self.feedback.reportError(msg)
featuresWithZ = []
raise QgsProcessingException(msg)
#print("Error addZtoPointFeatures")#,str(err.args) + ";" + str(repr(err)))
#raise QgsProcessingException("Error addZtoPointFeatures " + str(err.args))# + ";" + str(repr(err)))
return featuresWithZ
def drawCostPaths(self, rows, con, args, geomType, canvasItemList, mapCanvas):
resultPathsRubberBands = canvasItemList['paths']
rubberBand = None
cur_path_id = -1
for row in rows:
cur2 = con.cursor()
args['result_path_id'] = row[0]
args['result_source_id'] = sql.Literal(row[1])
args['result_target_id'] = sql.Literal(row[2])
args['result_cost'] = row[3]
if args['result_path_id'] != cur_path_id:
cur_path_id = args['result_path_id']
if rubberBand:
resultPathsRubberBands.append(rubberBand)
rubberBand = None
rubberBand = QgsRubberBand(mapCanvas, Utils.getRubberBandType(False))
rubberBand.setColor(QColor(255, 0, 0, 128))
rubberBand.setWidth(4)
if args['result_cost'] != -1:
query2 = sql.SQL("""
SELECT ST_AsText( ST_MakeLine(
(SELECT {geometry_vt} FROM {vertex_schema}.{vertex_table} WHERE id = {result_source_id}),
(SELECT {geometry_vt} FROM {vertex_schema}.{vertex_table} WHERE id = {result_target_id})
))
""").format(**args)
# Utils.logMessage(query2)
cur2.execute(query2)
row2 = cur2.fetchone()
# Utils.logMessage(str(row2[0]))
geom = QgsGeometry().fromWkt(str(row2[0]))
if geom.wkbType() == QgsWkbTypes.MultiLineString:
for line in geom.asMultiPolyline():
for pt in line:
rubberBand.addPoint(pt)
elif geom.wkbType() == QgsWkbTypes.LineString:
for pt in geom.asPolyline():
rubberBand.addPoint(pt)
# TODO label the edge instead of labeling the target points
if rubberBand:
resultPathsRubberBands.append(rubberBand)
rubberBand = None
resultNodesTextAnnotations = canvasItemList['annotations']
for row in rows:
cur2 = con.cursor()
args['result_seq'] = row[0]
args['result_source_id'] = sql.Literal(row[1])
result_target_id = row[2]
args['result_target_id'] = sql.Literal(result_target_id)
result_cost = row[3]
query2 = sql.SQL("""
SELECT ST_AsText( ST_startPoint({geometry}) ) FROM {edge_schema}.{edge_table}
WHERE {source} = {result_target_id}
UNION
SELECT ST_AsText( ST_endPoint( {geometry} ) ) FROM {edge_schema}.{edge_table}
WHERE {target} = {result_target_id}
""").format(**args)
cur2.execute(query2)
row2 = cur2.fetchone()
geom = QgsGeometry().fromWkt(str(row2[0]))
pt = geom.asPoint()
textDocument = QTextDocument("{0!s}:{1}".format(result_target_id, result_cost))
textAnnotation = QgsTextAnnotation()
textAnnotation.setMapPosition(geom.asPoint())
textAnnotation.setFrameSize(QSizeF(textDocument.idealWidth(), 20))
textAnnotation.setFrameOffsetFromReferencePoint(QPointF(20, -40))
textAnnotation.setDocument(textDocument)
QgsMapCanvasAnnotationItem(textAnnotation, mapCanvas)
resultNodesTextAnnotations.append(textAnnotation)
def __qgPntFromShplyPnt(self, shapelyPnt):
wkb_pnt = dumps(shapelyPnt)
qg_geom = QgsGeometry()
qg_geom.fromWkb(wkb_pnt)
return qg_geom.asPoint()
def get_missing_boundary_points_in_boundaries(self, db,
boundary_point_layer,
boundary_layer):
res = dict()
feedback = QgsProcessingFeedback()
extracted_vertices = processing.run("native:extractvertices", {
'INPUT': boundary_layer,
'OUTPUT': 'memory:'
},
feedback=feedback)
extracted_vertices_layer = extracted_vertices['OUTPUT']
# From vertices layer, get points with no overlap
overlapping_points = self.geometry.get_overlapping_points(
extracted_vertices_layer)
extracted_vertices_ids = [
feature.id() for feature in extracted_vertices_layer.getFeatures()
]
# Unpack list of lists into single list
overlapping_point_ids = [
item for sublist in overlapping_points for item in sublist
]
# Unpack list of lists into single list selecting only the first point
# per list. That means, discard overlapping points, and only keep one
cleaned_point_ids = [sublist[0] for sublist in overlapping_points]
# All vertices (even duplicated, due to the alg we use), minus all
# overlapping ids, plus only one of the overlapping ids
# This gets a list of all vertex ids with no duplicates
no_duplicate_ids = list(
set(extracted_vertices_ids) -
set(overlapping_point_ids)) + cleaned_point_ids
if boundary_point_layer.featureCount() == 0:
# Return all extracted and cleaned vertices
for feature in extracted_vertices_layer.getFeatures(
no_duplicate_ids):
if feature[db.names.T_ID_F] in res:
res[feature[db.names.T_ID_F]].append(feature.geometry())
else:
res[feature[db.names.T_ID_F]] = [feature.geometry()]
return res
index = QgsSpatialIndex(
boundary_point_layer.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes([])), feedback)
for feature in extracted_vertices_layer.getFeatures(no_duplicate_ids):
if feature.hasGeometry():
geom = feature.geometry()
diff_geom = QgsGeometry(geom)
# Use a custom bbox to include very near but not exactly equal points
point_vert = {
'x': diff_geom.asPoint().x(),
'y': diff_geom.asPoint().y()
}
bbox = QgsRectangle(
QgsPointXY(point_vert['x'] - 0.0001,
point_vert['y'] - 0.0001),
QgsPointXY(point_vert['x'] + 0.0001,
point_vert['y'] + 0.0001))
intersects = index.intersects(bbox)
if not intersects:
if feature[db.names.T_ID_F] in res:
res[feature[db.names.T_ID_F]].append(diff_geom)
else:
res[feature[db.names.T_ID_F]] = [diff_geom]
return res
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
fields = QgsFields()
fields.append(QgsField('POINTA', QVariant.Double, '', 24, 15))
fields.append(QgsField('POINTB', QVariant.Double, '', 24, 15))
fields.append(QgsField('POINTC', QVariant.Double, '', 24, 15))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Polygon, source.sourceCrs())
pts = []
ptDict = {}
ptNdx = -1
c = voronoi.Context()
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
geom = QgsGeometry(inFeat.geometry())
if geom.isNull():
continue
if geom.isMultipart():
points = geom.asMultiPoint()
else:
points = [geom.asPoint()]
for n, point in enumerate(points):
x = point.x()
y = point.y()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = (inFeat.id(), n)
feedback.setProgress(int(current * total))
if len(pts) < 3:
raise QgsProcessingException(
self.tr('Input file should contain at least 3 points. Choose '
'another file and try again.'))
uniqueSet = set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(*i) for i in uniqueSet])
c.triangulate = True
voronoi.voronoi(sl, c)
triangles = c.triangles
feat = QgsFeature()
total = 100.0 / len(triangles) if triangles else 1
for current, triangle in enumerate(triangles):
if feedback.isCanceled():
break
indices = list(triangle)
indices.append(indices[0])
polygon = []
attrs = []
step = 0
for index in indices:
fid, n = ptDict[ids[index]]
request = QgsFeatureRequest().setFilterFid(fid)
inFeat = next(source.getFeatures(request))
geom = QgsGeometry(inFeat.geometry())
if geom.isMultipart():
point = QgsPointXY(geom.asMultiPoint()[n])
else:
point = QgsPointXY(geom.asPoint())
polygon.append(point)
if step <= 3:
attrs.append(ids[index])
step += 1
feat.setAttributes(attrs)
geometry = QgsGeometry().fromPolygonXY([polygon])
feat.setGeometry(geometry)
sink.addFeature(feat, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def __qgPntFromShplyPnt(self, shapelyPnt):
wkbPnt = dumps(shapelyPnt)
qgGeom = QgsGeometry()
qgGeom.fromWkb(wkbPnt)
return qgGeom.asPoint()
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
fields = QgsFields()
fields.append(QgsField('POINTA', QVariant.Double, '', 24, 15))
fields.append(QgsField('POINTB', QVariant.Double, '', 24, 15))
fields.append(QgsField('POINTC', QVariant.Double, '', 24, 15))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Polygon,
source.sourceCrs())
pts = []
ptDict = {}
ptNdx = -1
c = voronoi.Context()
features = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
geom = QgsGeometry(inFeat.geometry())
if geom.isNull():
continue
if geom.isMultipart():
points = geom.asMultiPoint()
else:
points = [geom.asPoint()]
for n, point in enumerate(points):
x = point.x()
y = point.y()
pts.append((x, y))
ptNdx += 1
ptDict[ptNdx] = (inFeat.id(), n)
feedback.setProgress(int(current * total))
if len(pts) < 3:
raise QgsProcessingException(
self.tr('Input file should contain at least 3 points. Choose '
'another file and try again.'))
uniqueSet = set(item for item in pts)
ids = [pts.index(item) for item in uniqueSet]
sl = voronoi.SiteList([voronoi.Site(*i) for i in uniqueSet])
c.triangulate = True
voronoi.voronoi(sl, c)
triangles = c.triangles
feat = QgsFeature()
total = 100.0 / len(triangles) if triangles else 1
for current, triangle in enumerate(triangles):
if feedback.isCanceled():
break
indices = list(triangle)
indices.append(indices[0])
polygon = []
attrs = []
step = 0
for index in indices:
fid, n = ptDict[ids[index]]
request = QgsFeatureRequest().setFilterFid(fid)
inFeat = next(source.getFeatures(request))
geom = QgsGeometry(inFeat.geometry())
if geom.isMultipart():
point = QgsPointXY(geom.asMultiPoint()[n])
else:
point = QgsPointXY(geom.asPoint())
polygon.append(point)
if step <= 3:
attrs.append(ids[index])
step += 1
feat.setAttributes(attrs)
geometry = QgsGeometry().fromPolygon([polygon])
feat.setGeometry(geometry)
sink.addFeature(feat, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def run(self):
# Converter escala textual para numérica (denominador)
escala = self.escalaAvaliacao.currentText() # '1:100.000'
escalaAval = escala.split(':')[1].replace('.','')
escalaAval = int(escalaAval)
self.canvas.zoomScale(escalaAval)
listaHomologosXY = {} # dicionario yx.
listaHomologosZ = {} # dicionario z.
# Raio definido
raio = self.spinBox.value()
# Layers selecionados
layer1 = self.referenciaComboBox.currentLayer()
layer2 = self.avaliacaoComboBox.currentLayer()
# Teste para identificar se esta setado.
XY = False
Z = False
if self.xy.isChecked():
XY = True
if self.z.isChecked():
Z = True
# Troca de referência CRS para uma que utiliza medição em metros (3857).
source1 = layer1.crs()
source2 = layer2.crs()
dest = QgsCoordinateReferenceSystem(3857)
tr1 = QgsCoordinateTransform(source1, dest)
tr2 = QgsCoordinateTransform(source2, dest)
lista1 = [feat1 for feat1 in layer1.getFeatures()]
lista2 = [feat2 for feat2 in layer2.getFeatures()]
lista3 = []
spIndex1 = QgsSpatialIndex()
neighbour = QgsFeature()
for feat1 in lista1:
spIndex1.insertFeature(feat1) # transforma features em indices espaciais
geom1 = QgsGeometry(feat1.geometry())
geom1.transform(tr1)
raioTeste = raio
neighbour = None
encontrado = False
for feat2 in lista2:
pt = feat2.geometry().asPoint()
nearestid = spIndex1.nearestNeighbor(pt, 2)[0] # realiza a analise do vizinho mais próximo, numero de vizinhos é definido no segundo argumento.
#print nearestid
request = QgsFeatureRequest().setFilterFid(nearestid)
geom2 = QgsGeometry(feat2.geometry())
geom2.transform(tr2)
if geom1.buffer (raioTeste, 20 ) .contains (geom2):
raioTeste = sqrt (geom1.asPoint (). sqrDist (geom2.asPoint ()))
neighbour = feat2
encontrado = True
# apenas pra descobrir se não foi encontrado.
if encontrado == False:
#print u'\nHouve pontos nao encontrados dentro do raio definido.'
frase = ("<span style='color:purple'>HOUVE PONTOS NAO ENCONTRADOS.</span>")
lista3.append(frase)
else:
if XY:
listaHomologosXY[int(feat1.id()), int(neighbour.id())] = (raioTeste)
if Z:
listaHomologosZ[int(feat1.id()), int(neighbour.id())] = feat1.geometry().geometry().z() - neighbour.geometry().geometry().z()
lista2.remove(neighbour)
if XY or Z:
#print '\nHomologos: \n', listaHomologosXY.keys()
distAcum = 0
resultado2 = "<span style='color:orange'>DISTANCIA ENTRE PONTOS: </span>",[ round(v, 2) for v in listaHomologosXY.values()]
resultado1 = "<span style='color:orange'>PONTOS HOMOLOGOS: </span>",listaHomologosXY.keys()
#print '\nDistancia entre pontos Homologados:\n',resultado2
lista3.append(resultado1)
lista3.append(resultado2)
if XY:
distAcum = 0
for valorXY in listaHomologosXY.values():
distAcum += valorXY
resultado = int(distAcum / len(listaHomologosXY))
#print '\nDistancia media:\n', round(resultado,2)
b = "<span style='color:orange'>DISTANCIA MEDIA: </span>", round(resultado,2)
lista3.append(b)
if Z:
zAcum = 0
for valorZ in listaHomologosZ.values():
zAcum += valorZ
resultado = int(zAcum / len(listaHomologosZ))
#print '\nDiferenca media de elevacao: \n', round(resultado,3)
a = "<span style='color:orange'>DISTANCIA MEDIA DE ELEVACAO: </span>", round(resultado,3)
lista3.append(a)
# Formatação para apresentar QmessageBox de forma bem distribuida.
message = u""
one_data = u"<p>{0}</p>"
two_data = u"<p>{0} {1}</p>"
for data in lista3:
message += one_data.format(data) if type(data) == str else two_data.format(data[0], data[1])
QMessageBox.about(self, "RESULTADO: ", message )
