def control(self):
self.ids = []
self.polynum = self.ml.featureCount()
feat = QgsFeature()
provider = self.ml.dataProvider()
feats = provider.getFeatures()
self.emit(SIGNAL("runStatus(PyQt_PyObject)"), 0)
self.emit(SIGNAL("runRange(PyQt_PyObject)"), (0, self.polynum))
ne = 0
while feats.nextFeature(feat):
ne += 1
self.emit(SIGNAL("runStatus(PyQt_PyObject)"), ne)
geom = QgsGeometry(feat.geometry())
if geom.isMultipart():
multi_polygon = geom.asMultiPolygon()
for polygon in multi_polygon:
for ring in polygon:
for v in ring:
self.cintlen(str(v.x()))
self.cintlen(str(v.y()))
else:
polygon = geom.asPolygon()
for ring in polygon:
for v in ring:
self.cintlen(str(v.x()))
self.cintlen(str(v.y()))
self.ids.append(feat.id())
def convSplus(self, prec):
for i in range(0, self.polynum):
j = i + 1
self.plainTextEdit.appendPlainText("%s area%s" % (j, j))
self.plainTextEdit.appendPlainText("")
mod = min(self.ids)
p = 1
if mod==1:
p = 0
for ne in range(mod, self.polynum + mod):
pn = 1
feat = QgsFeature()
geom = QgsGeometry()
fiter = self.ml.getFeatures(QgsFeatureRequest(ne))
if fiter.nextFeature(feat):
geom = QgsGeometry(feat.geometry())
id = feat.id()+p
if geom.isMultipart():
multi_polygon = geom.asMultiPolygon()
for polygon in multi_polygon:
for ring in polygon:
for v in ring:
self.plainTextEdit.appendPlainText(
"area%s %s %s" % (id, round(v.x(), prec), round(v.y(), prec)))
pn += 1
self.plainTextEdit.appendPlainText("NA NA NA")
else:
polygon = geom.asPolygon()
for ring in polygon:
for v in ring:
self.plainTextEdit.appendPlainText(
"area%s %s %s" % (id, round(v.x(), prec), round(v.y(), prec)))
pn += 1
self.plainTextEdit.appendPlainText("NA NA NA")
if pn >= 10000:
QMessageBox.information(self,
"Too many points",
"Polygon No. %s contains to many points to read into GeoBUGS.\nSimplifying of polygon can solve this problem." % (id),
buttons=QMessageBox.Ok, defaultButton=QMessageBox.NoButton)
self.progressBar.setValue(100 * id / self.polynum)
self.plainTextEdit.appendPlainText("END")
def qGeometry(feature):
try:
geom = QgsGeometry(feature.geometry())
fid = feature.id()
if not geom.isMultipart():
if not geom.convertToMultiType():
raise Exception("unable to extract feature geometry (invalid geometry type)")
if geom.type() == 0:
return qPoints(geom.asMultiPoint())
elif geom.type() == 1:
return qLines(geom.asMultiPolyline(), fid)
elif geom.type() == 2:
return qPolygons(geom.asMultiPolygon(), fid)
else:
raise Exception("unable to extract feature geometry (unknown geometry type)")
except Exception, e:
raise Exception("unable to extract feature geometry: %s" % unicode(e))
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 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 processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.VECTOR))
pointCount = float(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QGis.WKBPoint, layer.crs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
featureCount = layer.featureCount()
total = 100.0 / pointCount if pointCount > 0 else 1
index = QgsSpatialIndex()
points = dict()
da = QgsDistanceArea()
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
# pick random feature
fid = random.randint(0, featureCount - 1)
f = layer.getFeatures(request.setFilterFid(fid)).next()
fGeom = QgsGeometry(f.geometry())
if fGeom.isMultipart():
lines = fGeom.asMultiPolyline()
# pick random line
lineId = random.randint(0, len(lines) - 1)
vertices = lines[lineId]
else:
vertices = fGeom.asPolyline()
# pick random segment
if len(vertices) == 2:
vid = 0
else:
vid = random.randint(0, len(vertices) - 2)
startPoint = vertices[vid]
endPoint = vertices[vid + 1]
length = da.measureLine(startPoint, endPoint)
dist = length * random.random()
if dist > minDistance:
d = dist / (length - dist)
rx = (startPoint.x() + d * endPoint.x()) / (1 + d)
ry = (startPoint.y() + d * endPoint.y()) / (1 + d)
# generate random point
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
progress.setPercentage(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
del writer
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
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())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
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 processAlgorithm(self, context, feedback):
layer = dataobjects.getLayerFromString(
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(), context)
pts = []
ptDict = {}
ptNdx = -1
c = voronoi.Context()
features = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
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.VECTOR))
pointCount = float(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QGis.WKBPoint, layer.dataProvider().crs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
featureCount = layer.featureCount()
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
da = QgsDistanceArea()
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
# pick random feature
fid = random.randint(0, featureCount - 1)
f = layer.getFeatures(request.setFilterFid(fid)).next()
fGeom = QgsGeometry(f.geometry())
if fGeom.isMultipart():
lines = fGeom.asMultiPolyline()
# pick random line
lineId = random.randint(0, len(lines) - 1)
vertices = lines[lineId]
else:
vertices = fGeom.asPolyline()
# pick random segment
if len(vertices) == 2:
vid = 0
else:
vid = random.randint(0, len(vertices) - 2)
startPoint = vertices[vid]
endPoint = vertices[vid + 1]
length = da.measureLine(startPoint, endPoint)
dist = length * random.random()
if dist > minDistance:
d = dist / (length - dist)
rx = (startPoint.x() + d * endPoint.x()) / (1 + d)
ry = (startPoint.y() + d * endPoint.y()) / (1 + d)
# generate random point
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if vector.checkMinDistance(pnt, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
writer.addFeature(f)
index.insertFeature(f)
points[nPoints] = pnt
nPoints += 1
progress.setPercentage(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
del writer
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 convArcInfo(self, prec):
for i in range(0, self.polynum):
j = i + 1
self.plainTextEdit.appendPlainText("%s area%s" % (j, j))
self.plainTextEdit.appendPlainText("\nregions")
provider = self.ml.dataProvider()
i = 1
n = 1
mod = min(self.ids)
p = 1
if mod == 1:
p = 0
for ne in range(mod, self.polynum + mod):
feat = QgsFeature()
geom = QgsGeometry()
fiter = self.ml.getFeatures(QgsFeatureRequest(ne))
if fiter.nextFeature(feat):
geom = QgsGeometry(feat.geometry())
if geom.isMultipart():
multi_polygon = geom.asMultiPolygon()
for polygon in multi_polygon:
for ring in polygon:
self.plainTextEdit.appendPlainText("%s area%s" %
(n, feat.id() + p))
n += 1
else:
polygon = geom.asPolygon()
for ring in polygon:
self.plainTextEdit.appendPlainText("%s area%s" %
(n, feat.id() + p))
n += 1
i += 1
self.plainTextEdit.appendPlainText("END")
n = 1
for ne in range(mod, self.polynum + mod):
pn = 1
feat = QgsFeature()
geom = QgsGeometry()
fiter = self.ml.getFeatures(QgsFeatureRequest(ne))
if fiter.nextFeature(feat):
geom = QgsGeometry(feat.geometry())
id = feat.id() + p
if geom.isMultipart():
multi_polygon = geom.asMultiPolygon()
for polygon in multi_polygon:
for ring in polygon:
self.plainTextEdit.appendPlainText("%s 0 0" % (n))
for v in ring:
self.plainTextEdit.appendPlainText(
"%s %s" %
(round(v.x(), prec), round(v.y(), prec)))
pn += 1
self.plainTextEdit.appendPlainText("END")
n += 1
else:
polygon = geom.asPolygon()
for ring in polygon:
self.plainTextEdit.appendPlainText("%s 0 0" % (n))
for v in ring:
self.plainTextEdit.appendPlainText(
"%s %s" % (round(v.x(), prec), round(v.y(), prec)))
pn += 1
self.plainTextEdit.appendPlainText("END")
n += 1
if pn >= 10000:
QMessageBox.information(
self,
"Too many points",
"Polygon No. %s contains to many points to read into GeoBUGS.\nSimplifying of polygon can solve this problem."
% (id),
buttons=QMessageBox.Ok,
defaultButton=QMessageBox.NoButton)
self.progressBar.setValue(100 * id / self.polynum)
self.plainTextEdit.appendPlainText("END")
def getSchnittpunkteAusPolygonen(self, overlapFeats, featureCrs,
laengsProfil, feedback):
schnittpunktFeatures = []
schnittLinesFeatures = []
ioFeat = 0
countPoints = 0
try:
for feat in overlapFeats:
#Feature bekommt neues Attribut Station
if ioFeat == 0:
fields = feat.fields()
fields.append(QgsField("station", QVariant.Double))
schnittpunktFeaturesOfThisPolygon = []
schnittpunktListOfPolygon = [
] #Liste [points, stations, feature.id's]
#check if Multipolygon
iMulti = 0
iRing = 0
tempGeom = QgsGeometry()
tempGeom.fromWkb(feat.geometry().asWkb())
#transform geom to Project.crs() if crs a different
if not featureCrs.authid() == QgsProject.instance().crs(
).authid():
trafo = QgsCoordinateTransform(featureCrs,
QgsProject.instance().crs(),
QgsProject.instance())
#transform Geom to Project.crs()
tempGeom.transform(trafo,
QgsCoordinateTransform.ForwardTransform,
False)
if tempGeom.isMultipart():
multiGeom = tempGeom.asMultiPolygon()
#Schleife zum Auflösen des Multiparts
for polygon in multiGeom:
for ring in polygon:
points = []
for pxy in ring:
#feedback.pushInfo(str(iMulti)+" "+str(iRing)+" "+str(pxy) + " " + str(type(pxy)))
points.append(QgsPoint(pxy.x(), pxy.y()))
singlePolygon = QgsGeometry().fromPolyline(points)
iRing = iRing + 1
#feedback.pushInfo(str(iMulti) + str(type(singlePolygon)) + str(polygon))
schnittpunktFeaturesOfThisPolygonItem = self.makeIntersectionFeatures(
feat, singlePolygon, laengsProfil, fields,
feedback)
for spfotp in schnittpunktFeaturesOfThisPolygonItem:
schnittpunktFeaturesOfThisPolygon.append(
spfotp)
#Liste [points, stations, feature.id's]
schnittpunktListOfPolygonItem = self.makeIntersectionPointsStationList(
feat, singlePolygon, laengsProfil, fields,
feedback)
for sp in schnittpunktListOfPolygonItem:
schnittpunktListOfPolygon.append(sp)
iMulti = iMulti + 1
else: # single Geometry
schnittpunktFeaturesOfThisPolygon = self.makeIntersectionFeatures(
feat, tempGeom, laengsProfil, fields, feedback)
schnittpunktListOfPolygon = self.makeIntersectionPointsStationList(
feat, tempGeom, laengsProfil, fields, feedback)
#create LineFeatures
schnittLinesFeats = self.makeLineFeaturesFromPointStationList(
feat, schnittpunktListOfPolygon, laengsProfil, feedback)
for f in schnittLinesFeats:
schnittLinesFeatures.append(f)
#add to list
for schnittFeat in schnittpunktFeaturesOfThisPolygon: #Intersection Feature in project.crs()
schnittpunktFeatures.append(schnittFeat)
#feedback.pushInfo(str(schnittFeat.attributes()))
ioFeat = ioFeat + 1
#count Intersections
countPoints = countPoints + len(
schnittpunktFeaturesOfThisPolygon)
except:
msg = self.tr(
"Error: Creating Intersections Geometry {0} Feature {1}"
).format(str(type(feat.geometry())), str(feat.attributes()))
feedback.reportError(msg)
raise QgsProcessingException(msg)
msgInfo = self.tr("Intersected Lines: {0} Intersections: {1}").format(
ioFeat, countPoints)
feedback.pushInfo(msgInfo)
return schnittpunktFeatures, schnittLinesFeatures
