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 toQgsGeometry(self):
count = len(self.pts)
if count > 1:
pts = map(pointToQgsPoint, self.pts)
return QgsGeometry.fromMultiPoint(pts)
if count == 1:
return QgsGeometry.fromPoint(pointToQgsPoint(self.pts[0]))
return QgsGeometry()
def flipFeature(self, layer, feature, geomType=None, refreshCanvas=False):
"""
Inverts the flow from a given feature. THE GIVEN FEATURE IS ALTERED. Standard behaviour is to not
refresh canvas map.
:param layer: layer containing the target feature for flipping.
:param feature: feature to be flipped.
:param geomType: if layer geometry type is not given, it'll calculate it (0,1 or 2)
:param refreshCanvas: indicates whether the canvas should be refreshed after flipping feature.
:returns: flipped feature as of [layer, feature, geometry_type].
"""
if not geomType:
geomType = layer.geometryType()
# getting whether geometry is multipart or not
isMulti = QgsWKBTypes.isMultiType(int(layer.wkbType()))
geom = feature.geometry()
if geomType == 0:
if isMulti:
nodes = geom.asMultiPoint()
# inverting the point list by parts
for idx, part in enumerate(nodes):
nodes[idx] = part[::-1]
# setting flipped geometry
flippedFeatureGeom = QgsGeometry.fromMultiPoint(nodes)
else:
# inverting the point list
nodes = geom.asPoint()
nodes = nodes[::-1]
flippedFeatureGeom = QgsGeometry.fromPoint(nodes)
elif geomType == 1:
if isMulti:
nodes = geom.asMultiPolyline()
for idx, part in enumerate(nodes):
nodes[idx] = part[::-1]
flippedFeatureGeom = QgsGeometry.fromMultiPolyline(nodes)
else:
nodes = geom.asPolyline()
nodes = nodes[::-1]
flippedFeatureGeom = QgsGeometry.fromPolyline(nodes)
elif geomType == 2:
if isMulti:
nodes = geom.asMultiPolygon()
for idx, part in enumerate(nodes):
nodes[idx] = part[::-1]
flippedFeatureGeom = QgsGeometry.fromMultiPolygon(nodes)
else:
nodes = geom.asPolygon()
nodes = nodes[::-1]
flippedFeatureGeom = QgsGeometry.fromPolygon(nodes)
# setting feature geometry to the flipped one
# feature.setGeometry(flippedFeatureGeom)
# layer.updateFeature(feature)
layer.changeGeometry(feature.id(), flippedFeatureGeom)
if refreshCanvas:
self.iface.mapCanvas().refresh()
return [layer, feature, geomType]
def parse_geometry(gr):
"""node s ISLH grafikou"""
g = gr[0] #obraz ma jen jeden prvek
geom = (
QgsGeometry.fromPoint(islh_parser.parse_point(g)) if g.tag == 'B'
else QgsGeometry.fromPolyline(islh_parser.parse_line(g)) if g.tag == 'L'
else QgsGeometry.fromMultiPoint(islh_parser.parse_multipoint(g)) if g.tag == 'MB'
else QgsGeometry.fromMultiPolyline(islh_parser.parse_multiline(g)) if g.tag == 'ML'
else QgsGeometry.fromPolygon(islh_parser.parse_polygon(g)) if g.tag == 'P'
else QgsGeometry.fromMultiPolygon(islh_parser.parse_multipolygon(g)) if g.tag == 'MP'
else None)
return(geom)
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 __point_grid(self, feature, wkb_type):
if feature.geometry().isMultipart():
points = feature.geometry().asMultiPoint()
else:
points = list()
points.append(feature.geometry().asPoint())
snapped_points = self.__points_to_grid(points)
if feature.geometry().isMultipart():
geom = QgsGeometry.fromMultiPoint(snapped_points)
else:
geom = QgsGeometry.fromPoint(snapped_points[0])
return geom
def spGeometry(geom, type):
def split(L):
n = len(L)/2
return [L[:n], L[n:]]
if type == "Polygon":
coords = [map(lambda p: QgsPoint(*p), zip(*split(list(po.do_slot('coords')))))
for po in geom.do_slot('Polygons')]
coords = QgsGeometry.fromMultiPolygon([coords])
elif type == "LineString":
coords = [map(lambda p: QgsPoint(*p), zip(*split(list(line.do_slot('coords')))))
for line in geom.do_slot('Lines')]
coords = QgsGeometry.fromMultiPolyline(coords)
elif type == "Point":
coords = [QgsPoint(*geom)]
coords = QgsGeometry.fromMultiPoint(coords)
else:
raise Exception("unable to convert geometries")
return coords
def build_qgis_feature(self, vector_item):
"""
Constructs a QGIS feature for rendering
:param vector_item: The item returned
:return a VectorFeature that can be rendered by QGIS
"""
feature = VectorFeature()
geometry = vector_item[KEY_JSON_GEOMETRY]
coordinates = geometry[KEY_JSON_GEOMETRY_COORDINATES]
geometry_type = geometry[KEY_JSON_GEOMETRY_TYPE]
if geometry_type == u'Point':
feature.setGeometry(QgsGeometry.fromPoint(self.get_point_from_json(coordinates)))
elif geometry_type == u'LineString':
feature.setGeometry(QgsGeometry.fromPolyline(self.get_linestring_from_json(coordinates)))
elif geometry_type == u'MultiPoint':
feature.setGeometry(QgsGeometry.fromMultiPoint(self.get_linestring_from_json(coordinates)))
elif geometry_type == u'Polygon':
feature.setGeometry(QgsGeometry.fromPolygon(self.get_polygon_from_json(coordinates)))
elif geometry_type == u'MultiLineString':
feature.setGeometry(QgsGeometry.fromMultiPolyline(self.get_polygon_from_json(coordinates)))
elif geometry_type == u'MultiPolygon':
feature.setGeometry(QgsGeometry.fromMultiPolygon(self.get_multipolygon_from_json(coordinates)))
else:
QgsMessageLog.instance().logMessage(u"Encountered odd geometry type: " + geometry_type, TAG_NAME,
level=QgsMessageLog.CRITICAL)
feature.geometry_type = geometry_type
attributes = self.get_attributes_from_json(vector_item[KEY_JSON_PROPERTIES])
fields = QgsFields()
values = []
for key, value in attributes.iteritems():
type_value = None
if key.endswith(u'int'):
type_value = QVariant.Int
elif key.endswith(u'dbl'):
type_value = QVariant.Double
else:
type_value = QVariant.String
fields.append(QgsField(key, type_value))
values.append(value)
feature.setFields(fields)
feature.setAttributes(values)
return feature
def processFeature(self, feature, feedback):
if feature.hasGeometry():
geom = feature.geometry()
geomType = QgsWkbTypes.flatType(geom.wkbType())
newGeom = None
if geomType == QgsWkbTypes.Point:
points = self._gridify([geom.asPoint()], self.h_spacing,
self.v_spacing)
newGeom = QgsGeometry.fromPoint(points[0])
elif geomType == QgsWkbTypes.MultiPoint:
points = self._gridify(geom.asMultiPoint(), self.h_spacing,
self.v_spacing)
newGeom = QgsGeometry.fromMultiPoint(points)
elif geomType == QgsWkbTypes.LineString:
points = self._gridify(geom.asPolyline(), self.h_spacing,
self.v_spacing)
if len(points) < 2:
feedback.reportError(
self.tr(
'Failed to gridify feature with FID {0}').format(
feature.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromPolyline(points)
elif geomType == QgsWkbTypes.MultiLineString:
polyline = []
for line in geom.asMultiPolyline():
points = self._gridify(line, self.h_spacing,
self.v_spacing)
if len(points) > 1:
polyline.append(points)
if len(polyline) <= 0:
feedback.reportError(
self.tr(
'Failed to gridify feature with FID {0}').format(
feature.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolyline(polyline)
elif geomType == QgsWkbTypes.Polygon:
polygon = []
for line in geom.asPolygon():
points = self._gridify(line, self.h_spacing,
self.v_spacing)
if len(points) > 1:
polygon.append(points)
if len(polygon) <= 0:
feedback.reportError(
self.tr(
'Failed to gridify feature with FID {0}').format(
feature.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromPolygon(polygon)
elif geomType == QgsWkbTypes.MultiPolygon:
multipolygon = []
for polygon in geom.asMultiPolygon():
newPolygon = []
for line in polygon:
points = self._gridify(line, self.h_spacing,
self.v_spacing)
if len(points) > 2:
newPolygon.append(points)
if len(newPolygon) > 0:
multipolygon.append(newPolygon)
if len(multipolygon) <= 0:
feedback.reportError(
self.tr(
'Failed to gridify feature with FID {0}').format(
feature.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolygon(multipolygon)
if newGeom is not None:
feature.setGeometry(newGeom)
else:
feature.clearGeometry()
return feature
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_VECTOR))
startPoints = dataobjects.getObjectFromUri(
self.getParameterValue(self.START_POINTS))
strategy = self.getParameterValue(self.STRATEGY)
travelCost = self.getParameterValue(self.TRAVEL_COST)
directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
forwardValue = self.getParameterValue(self.VALUE_FORWARD)
backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
speedFieldName = self.getParameterValue(self.SPEED_FIELD)
defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
tolerance = self.getParameterValue(self.TOLERANCE)
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
writerPoints = self.getOutputFromName(
self.OUTPUT_POINTS).getVectorWriter(
fields,
QgsWkbTypes.MultiPoint,
layer.crs())
writerPolygons = self.getOutputFromName(
self.OUTPUT_POLYGON).getVectorWriter(
fields,
QgsWkbTypes.Polygon,
layer.crs())
directionField = -1
if directionFieldName is not None:
directionField = layer.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName is not None:
speedField = layer.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(layer,
directionField,
forwardValue,
backwardValue,
bothValue,
defaultDirection)
distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField,
defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(iface.mapCanvas().mapSettings().destinationCrs(),
iface.mapCanvas().hasCrsTransformEnabled(),
tolerance)
feedback.pushInfo(self.tr('Loading start points...'))
request = QgsFeatureRequest()
request.setFlags(request.flags() ^ QgsFeatureRequest.SubsetOfAttributes)
features = vector.features(startPoints, request)
points = []
for f in features:
points.append(f.geometry().asPoint())
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, points)
feedback.pushInfo(self.tr('Calculating service areas...'))
graph = builder.graph()
vertices = []
upperBoundary = []
lowerBoundary = []
total = 100.0 / len(snappedPoints)
for i, p in enumerate(snappedPoints):
idxStart = graph.findVertex(snappedPoints[i])
origPoint = points[i].toString()
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
for j, v in enumerate(cost):
if v > travelCost and tree[j] != -1:
vertexId = graph.edge(tree[j]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(j)
for j in vertices:
upperBoundary.append(graph.vertex(graph.edge(tree[j]).inVertex()).point())
lowerBoundary.append(graph.vertex(graph.edge(tree[j]).outVertex()).point())
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = origPoint
writerPoints.addFeature(feat)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = origPoint
writerPoints.addFeature(feat)
upperBoundary.append(startPoint)
lowerBoundary.append(startPoint)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
geom = geomUpper.convexHull()
feat.setGeometry(geom)
feat['type'] = 'upper'
feat['start'] = origPoint
writerPolygons.addFeature(feat)
geom = geomLower.convexHull()
feat.setGeometry(geom)
feat['type'] = 'lower'
feat['start'] = origPoint
writerPolygons.addFeature(feat)
vertices[:] = []
upperBoundary[:] = []
lowerBoundary[:] = []
feedback.setProgress(int(i * total))
del writerPoints
del writerPolygons
def processAlgorithm(self, parameters, context, feedback):
network = self.parameterAsSource(parameters, self.INPUT, context)
startPoint = self.parameterAsPoint(parameters, self.START_POINT, context)
strategy = self.parameterAsEnum(parameters, self.STRATEGY, context)
travelCost = self.parameterAsDouble(parameters, self.TRAVEL_COST, context)
directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context)
forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context)
backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context)
bothValue = self.parameterAsString(parameters, self.VALUE_BOTH, context)
defaultDirection = self.parameterAsEnum(parameters, self.DEFAULT_DIRECTION, context)
speedFieldName = self.parameterAsString(parameters, self.SPEED_FIELD, context)
defaultSpeed = self.parameterAsDouble(parameters, self.DEFAULT_SPEED, context)
tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context)
directionField = -1
if directionFieldName:
directionField = network.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName:
speedField = network.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(network,
directionField,
forwardValue,
backwardValue,
bothValue,
defaultDirection)
distUnit = context.project().crs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField,
defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(context.project().crs(),
True,
tolerance)
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, [startPoint], feedback)
feedback.pushInfo(self.tr('Calculating service area...'))
graph = builder.graph()
idxStart = graph.findVertex(snappedPoints[0])
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
vertices = []
for i, v in enumerate(cost):
if v > travelCost and tree[i] != -1:
vertexId = graph.edge(tree[i]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(i)
upperBoundary = []
lowerBoundary = []
for i in vertices:
upperBoundary.append(graph.vertex(graph.edge(tree[i]).inVertex()).point())
lowerBoundary.append(graph.vertex(graph.edge(tree[i]).outVertex()).point())
feedback.pushInfo(self.tr('Writing results...'))
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
(sinkPoints, pointsId) = self.parameterAsSink(parameters, self.OUTPUT_POINTS, context,
fields, QgsWkbTypes.MultiPoint, network.sourceCrs())
(sinkPolygon, polygonId) = self.parameterAsSink(parameters, self.OUTPUT_POLYGON, context,
fields, QgsWkbTypes.Polygon, network.sourceCrs())
results = {}
if sinkPoints:
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
sinkPoints.addFeature(feat, QgsFeatureSink.FastInsert)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
sinkPoints.addFeature(feat, QgsFeatureSink.FastInsert)
upperBoundary.append(startPoint)
lowerBoundary.append(startPoint)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
results[self.OUTPUT_POINTS] = pointsId
if sinkPolygon:
geom = geomUpper.convexHull()
feat.setGeometry(geom)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
sinkPolygon.addFeature(feat, QgsFeatureSink.FastInsert)
geom = geomLower.convexHull()
feat.setGeometry(geom)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
sinkPolygon.addFeature(feat, QgsFeatureSink.FastInsert)
results[self.OUTPUT_POLYGON] = polygonId
return results
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_VECTOR))
startPoint = self.getParameterValue(self.START_POINT)
strategy = self.getParameterValue(self.STRATEGY)
travelCost = self.getParameterValue(self.TRAVEL_COST)
directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
forwardValue = self.getParameterValue(self.VALUE_FORWARD)
backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
speedFieldName = self.getParameterValue(self.SPEED_FIELD)
defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
tolerance = self.getParameterValue(self.TOLERANCE)
tmp = startPoint.split(',')
startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
directionField = -1
if directionFieldName is not None:
directionField = layer.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName is not None:
speedField = layer.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(layer,
directionField,
forwardValue,
backwardValue,
bothValue,
defaultDirection)
distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField,
defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(iface.mapCanvas().mapSettings().destinationCrs(),
iface.mapCanvas().hasCrsTransformEnabled(),
tolerance)
progress.setInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, [startPoint])
progress.setInfo(self.tr('Calculating service area...'))
graph = builder.graph()
idxStart = graph.findVertex(snappedPoints[0])
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
vertices = []
for i, v in enumerate(cost):
if v > travelCost and tree[i] != -1:
vertexId = graph.edge(tree [i]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(i)
upperBoundary = []
lowerBoundary = []
for i in vertices:
upperBoundary.append(graph.vertex(graph.edge(tree[i]).inVertex()).point())
lowerBoundary.append(graph.vertex(graph.edge(tree[i]).outVertex()).point())
progress.setInfo(self.tr('Writting results...'))
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
writer = self.getOutputFromName(
self.OUTPUT_POINTS).getVectorWriter(
fields,
QgsWkbTypes.MultiPoint,
layer.crs())
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
writer.addFeature(feat)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
writer.addFeature(feat)
del writer
writer = self.getOutputFromName(
self.OUTPUT_POLYGON).getVectorWriter(
fields,
QgsWkbTypes.Polygon,
layer.crs())
geom = geomUpper.convexHull()
feat.setGeometry(geom)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
writer.addFeature(feat)
geom = geomLower.convexHull()
feat.setGeometry(geom)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
writer.addFeature(feat)
del writer
def processAlgorithm(self, feedback):
layer = dataobjects.getLayerFromString(self.getParameterValue(self.INPUT))
buf = self.getParameterValue(self.BUFFER)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields().toList(), QgsWkbTypes.Polygon, 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 = 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()
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[0], i[1], sitenum=j) for (j,
i) in enumerate(uniqueSet)])
voronoi.voronoi(sl, c)
inFeat = QgsFeature()
current = 0
if len(c.polygons) == 0:
raise GeoAlgorithmExecutionException(
self.tr('There were no polygons created.'))
total = 100.0 / len(c.polygons)
for (site, edges) in list(c.polygons.items()):
request = QgsFeatureRequest().setFilterFid(ptDict[ids[site]])
inFeat = next(layer.getFeatures(request))
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
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
useField = bool(fieldName)
field_index = None
f = QgsField('value', QVariant.String, '', 255)
if useField:
field_index = source.fields().lookupField(fieldName)
fType = source.fields()[field_index].type()
if fType in [QVariant.Int, QVariant.UInt, QVariant.LongLong, QVariant.ULongLong]:
f.setType(fType)
f.setLength(20)
elif fType == QVariant.Double:
f.setType(QVariant.Double)
f.setLength(20)
f.setPrecision(6)
else:
f.setType(QVariant.String)
f.setLength(255)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 20))
fields.append(f)
fields.append(QgsField('area', QVariant.Double, '', 20, 6))
fields.append(QgsField('perim', QVariant.Double, '', 20, 6))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Polygon, source.sourceCrs())
outFeat = QgsFeature()
outGeom = QgsGeometry()
fid = 0
val = None
if useField:
unique = source.uniqueValues(field_index)
current = 0
total = 100.0 / (source.featureCount() * len(unique)) if source.featureCount() else 1
for i in unique:
if feedback.isCanceled():
break
first = True
hull = []
features = source.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([field_index]))
for f in features:
if feedback.isCanceled():
break
idVar = f.attributes()[field_index]
if str(idVar).strip() == str(i).strip():
if first:
val = idVar
first = False
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
feedback.setProgress(int(current * total))
if len(hull) >= 3:
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
if outGeom:
area = outGeom.geometry().area()
perim = outGeom.geometry().perimeter()
else:
area = NULL
perim = NULL
outFeat.setGeometry(outGeom)
outFeat.setAttributes([fid, val, area, perim])
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
raise QgsProcessingException(
self.tr('Exception while computing convex hull'))
fid += 1
else:
hull = []
total = 100.0 / source.featureCount() if source.featureCount() else 1
features = source.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([]))
for current, f in enumerate(features):
if feedback.isCanceled():
break
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
feedback.setProgress(int(current * total))
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
if outGeom:
area = outGeom.geometry().area()
perim = outGeom.geometry().perimeter()
else:
area = NULL
perim = NULL
outFeat.setGeometry(outGeom)
outFeat.setAttributes([0, 'all', area, perim])
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
raise QgsProcessingException(
self.tr('Exception while computing convex hull'))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(self.getParameterValue(
self.INPUT))
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: %s/%s' % (hSpacing, vSpacing)))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields(), layer.wkbType(), layer.crs())
features = vector.features(layer)
total = 100.0 / len(features)
for current, f in enumerate(features):
geom = f.geometry()
geomType = geom.wkbType()
if geomType == QgsWkbTypes.Point:
points = self._gridify([geom.asPoint()], hSpacing, vSpacing)
newGeom = QgsGeometry.fromPoint(points[0])
elif geomType == QgsWkbTypes.MultiPoint:
points = self._gridify(geom.aMultiPoint(), hSpacing, vSpacing)
newGeom = QgsGeometry.fromMultiPoint(points)
elif geomType == QgsWkbTypes.LineString:
points = self._gridify(geom.asPolyline(), hSpacing, vSpacing)
if len(points) < 2:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr('Failed to gridify feature with FID %s' %
f.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromPolyline(points)
elif geomType == QgsWkbTypes.MultiLineString:
polyline = []
for line in geom.asMultiPolyline():
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 1:
polyline.append(points)
if len(polyline) <= 0:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr('Failed to gridify feature with FID %s' %
f.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolyline(polyline)
elif geomType == QgsWkbTypes.Polygon:
polygon = []
for line in geom.asPolygon():
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 1:
polygon.append(points)
if len(polygon) <= 0:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr('Failed to gridify feature with FID %s' %
f.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromPolygon(polygon)
elif geomType == QgsWkbTypes.MultiPolygon:
multipolygon = []
for polygon in geom.asMultiPolygon():
newPolygon = []
for line in polygon:
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 2:
newPolygon.append(points)
if len(newPolygon) > 0:
multipolygon.append(newPolygon)
if len(multipolygon) <= 0:
ProcessingLog.addToLog(
ProcessingLog.LOG_INFO,
self.tr('Failed to gridify feature with FID %s' %
f.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolygon(multipolygon)
if newGeom is not None:
feat = QgsFeature()
feat.setGeometry(newGeom)
feat.setAttributes(f.attributes())
writer.addFeature(feat)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.INPUT_VECTOR), context)
startPoints = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.START_POINTS), context)
strategy = self.getParameterValue(self.STRATEGY)
travelCost = self.getParameterValue(self.TRAVEL_COST)
directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
forwardValue = self.getParameterValue(self.VALUE_FORWARD)
backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
speedFieldName = self.getParameterValue(self.SPEED_FIELD)
defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
tolerance = self.getParameterValue(self.TOLERANCE)
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
writerPoints = self.getOutputFromName(
self.OUTPUT_POINTS).getVectorWriter(fields, QgsWkbTypes.MultiPoint,
layer.crs(), context)
writerPolygons = self.getOutputFromName(
self.OUTPUT_POLYGON).getVectorWriter(fields, QgsWkbTypes.Polygon,
layer.crs(), context)
directionField = -1
if directionFieldName is not None:
directionField = layer.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName is not None:
speedField = layer.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(layer, directionField, forwardValue,
backwardValue, bothValue,
defaultDirection)
distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(
distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(
iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance)
feedback.pushInfo(self.tr('Loading start points...'))
request = QgsFeatureRequest()
request.setFlags(request.flags()
^ QgsFeatureRequest.SubsetOfAttributes)
features = QgsProcessingUtils.getFeatures(startPoints, context,
request)
points = []
for f in features:
points.append(f.geometry().asPoint())
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, points)
feedback.pushInfo(self.tr('Calculating service areas...'))
graph = builder.graph()
vertices = []
upperBoundary = []
lowerBoundary = []
total = 100.0 / len(snappedPoints)
for i, p in enumerate(snappedPoints):
idxStart = graph.findVertex(snappedPoints[i])
origPoint = points[i].toString()
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
for j, v in enumerate(cost):
if v > travelCost and tree[j] != -1:
vertexId = graph.edge(tree[j]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(j)
for j in vertices:
upperBoundary.append(
graph.vertex(graph.edge(tree[j]).inVertex()).point())
lowerBoundary.append(
graph.vertex(graph.edge(tree[j]).outVertex()).point())
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = origPoint
writerPoints.addFeature(feat)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = origPoint
writerPoints.addFeature(feat)
upperBoundary.append(origPoint)
lowerBoundary.append(origPoint)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
geom = geomUpper.convexHull()
feat.setGeometry(geom)
feat['type'] = 'upper'
feat['start'] = origPoint
writerPolygons.addFeature(feat)
geom = geomLower.convexHull()
feat.setGeometry(geom)
feat['type'] = 'lower'
feat['start'] = origPoint
writerPolygons.addFeature(feat)
vertices[:] = []
upperBoundary[:] = []
lowerBoundary[:] = []
feedback.setProgress(int(i * total))
del writerPoints
del writerPolygons
def testFromMultiPoint(self):
myMultiPoint = QgsGeometry.fromMultiPoint([
(QgsPoint(0, 0)),(QgsPoint(1, 1))])
myMessage = ('Expected:\n%s\nGot:\n%s\n' %
(QGis.WKBMultiPoint, myMultiPoint.type()))
assert myMultiPoint.wkbType() == QGis.WKBMultiPoint, myMessage
def processAlgorithm(self, parameters, context, feedback):
network = self.parameterAsSource(parameters, self.INPUT, context)
startPoint = self.parameterAsPoint(parameters, self.START_POINT, context)
strategy = self.parameterAsEnum(parameters, self.STRATEGY, context)
travelCost = self.parameterAsDouble(parameters, self.TRAVEL_COST, context)
directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context)
forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context)
backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context)
bothValue = self.parameterAsString(parameters, self.VALUE_BOTH, context)
defaultDirection = self.parameterAsEnum(parameters, self.DEFAULT_DIRECTION, context)
speedFieldName = self.parameterAsString(parameters, self.SPEED_FIELD, context)
defaultSpeed = self.parameterAsDouble(parameters, self.DEFAULT_SPEED, context)
tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context)
directionField = -1
if directionFieldName:
directionField = network.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName:
speedField = network.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(network,
directionField,
forwardValue,
backwardValue,
bothValue,
defaultDirection)
distUnit = context.project().crs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField,
defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(context.project().crs(),
True,
tolerance)
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, [startPoint], feedback)
feedback.pushInfo(self.tr('Calculating service area...'))
graph = builder.graph()
idxStart = graph.findVertex(snappedPoints[0])
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
vertices = []
for i, v in enumerate(cost):
if v > travelCost and tree[i] != -1:
vertexId = graph.edge(tree[i]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(i)
upperBoundary = []
lowerBoundary = []
for i in vertices:
upperBoundary.append(graph.vertex(graph.edge(tree[i]).inVertex()).point())
lowerBoundary.append(graph.vertex(graph.edge(tree[i]).outVertex()).point())
feedback.pushInfo(self.tr('Writing results...'))
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
(sinkPoints, pointsId) = self.parameterAsSink(parameters, self.OUTPUT_POINTS, context,
fields, QgsWkbTypes.MultiPoint, network.sourceCrs())
(sinkPolygon, polygonId) = self.parameterAsSink(parameters, self.OUTPUT_POLYGON, context,
fields, QgsWkbTypes.Polygon, network.sourceCrs())
results = {}
if sinkPoints:
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
sinkPoints.addFeature(feat, QgsFeatureSink.FastInsert)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
sinkPoints.addFeature(feat, QgsFeatureSink.FastInsert)
upperBoundary.append(startPoint)
lowerBoundary.append(startPoint)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
results[self.OUTPUT_POINTS] = pointsId
if sinkPolygon:
geom = geomUpper.convexHull()
feat.setGeometry(geom)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
sinkPolygon.addFeature(feat, QgsFeatureSink.FastInsert)
geom = geomLower.convexHull()
feat.setGeometry(geom)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
sinkPolygon.addFeature(feat, QgsFeatureSink.FastInsert)
results[self.OUTPUT_POLYGON] = polygonId
return results
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: {0}/{1}').format(hSpacing, vSpacing))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), layer.wkbType(), layer.crs(),
context)
features = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
for current, f in enumerate(features):
geom = f.geometry()
geomType = geom.wkbType()
if geomType == QgsWkbTypes.Point:
points = self._gridify([geom.asPoint()], hSpacing, vSpacing)
newGeom = QgsGeometry.fromPoint(points[0])
elif geomType == QgsWkbTypes.MultiPoint:
points = self._gridify(geom.aMultiPoint(), hSpacing, vSpacing)
newGeom = QgsGeometry.fromMultiPoint(points)
elif geomType == QgsWkbTypes.LineString:
points = self._gridify(geom.asPolyline(), hSpacing, vSpacing)
if len(points) < 2:
QgsMessageLog.logMessage(self.tr('Failed to gridify feature with FID {0}').format(f.id()), self.tr('Processing'), QgsMessageLog.INFO)
newGeom = None
else:
newGeom = QgsGeometry.fromPolyline(points)
elif geomType == QgsWkbTypes.MultiLineString:
polyline = []
for line in geom.asMultiPolyline():
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 1:
polyline.append(points)
if len(polyline) <= 0:
QgsMessageLog.logMessage(self.tr('Failed to gridify feature with FID {0}').format(f.id()), self.tr('Processing'), QgsMessageLog.INFO)
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolyline(polyline)
elif geomType == QgsWkbTypes.Polygon:
polygon = []
for line in geom.asPolygon():
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 1:
polygon.append(points)
if len(polygon) <= 0:
QgsMessageLog.logMessage(self.tr('Failed to gridify feature with FID {0}').format(f.id()), self.tr('Processing'), QgsMessageLog.INFO)
newGeom = None
else:
newGeom = QgsGeometry.fromPolygon(polygon)
elif geomType == QgsWkbTypes.MultiPolygon:
multipolygon = []
for polygon in geom.asMultiPolygon():
newPolygon = []
for line in polygon:
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 2:
newPolygon.append(points)
if len(newPolygon) > 0:
multipolygon.append(newPolygon)
if len(multipolygon) <= 0:
QgsMessageLog.logMessage(self.tr('Failed to gridify feature with FID {0}').format(f.id()), self.tr('Processing'), QgsMessageLog.INFO)
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolygon(multipolygon)
if newGeom is not None:
feat = QgsFeature()
feat.setGeometry(newGeom)
feat.setAttributes(f.attributes())
writer.addFeature(feat)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, parameters, context, feedback):
network = self.parameterAsSource(parameters, self.INPUT, context)
startPoints = self.parameterAsSource(parameters, self.START_POINTS,
context)
strategy = self.parameterAsEnum(parameters, self.STRATEGY, context)
travelCost = self.parameterAsDouble(parameters, self.TRAVEL_COST,
context)
directionFieldName = self.parameterAsString(parameters,
self.DIRECTION_FIELD,
context)
forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD,
context)
backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD,
context)
bothValue = self.parameterAsString(parameters, self.VALUE_BOTH,
context)
defaultDirection = self.parameterAsEnum(parameters,
self.DEFAULT_DIRECTION,
context)
speedFieldName = self.parameterAsString(parameters, self.SPEED_FIELD,
context)
defaultSpeed = self.parameterAsDouble(parameters, self.DEFAULT_SPEED,
context)
tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context)
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
directionField = -1
if directionFieldName:
directionField = network.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName:
speedField = network.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(network, directionField,
forwardValue, backwardValue,
bothValue, defaultDirection)
distUnit = context.project().crs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(
distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(network.sourceCrs(), True, tolerance)
feedback.pushInfo(self.tr('Loading start points...'))
request = QgsFeatureRequest()
request.setFlags(request.flags()
^ QgsFeatureRequest.SubsetOfAttributes)
request.setDestinationCrs(network.sourceCrs())
features = startPoints.getFeatures(request)
total = 100.0 / startPoints.featureCount() if startPoints.featureCount(
) else 0
points = []
for current, f in enumerate(features):
if feedback.isCanceled():
break
points.append(f.geometry().asPoint())
feedback.setProgress(int(current * total))
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, points, feedback)
feedback.pushInfo(self.tr('Calculating service areas...'))
graph = builder.graph()
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.MultiPoint,
network.sourceCrs())
vertices = []
upperBoundary = []
lowerBoundary = []
total = 100.0 / len(snappedPoints) if snappedPoints else 1
for i, p in enumerate(snappedPoints):
if feedback.isCanceled():
break
idxStart = graph.findVertex(snappedPoints[i])
origPoint = points[i].toString()
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
for j, v in enumerate(cost):
if v > travelCost and tree[j] != -1:
vertexId = graph.edge(tree[j]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(j)
for j in vertices:
upperBoundary.append(
graph.vertex(graph.edge(tree[j]).inVertex()).point())
lowerBoundary.append(
graph.vertex(graph.edge(tree[j]).outVertex()).point())
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = origPoint
sink.addFeature(feat, QgsFeatureSink.FastInsert)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = origPoint
sink.addFeature(feat, QgsFeatureSink.FastInsert)
vertices[:] = []
upperBoundary[:] = []
lowerBoundary[:] = []
feedback.setProgress(int(i * total))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
buf = self.parameterAsDouble(parameters, self.BUFFER, context)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, source.fields(),
QgsWkbTypes.Polygon,
source.sourceCrs())
outFeat = QgsFeature()
extent = source.sourceExtent()
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 = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
geom = 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()
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[0], i[1], sitenum=j)
for (j, i) in enumerate(uniqueSet)
])
voronoi.voronoi(sl, c)
inFeat = QgsFeature()
current = 0
if len(c.polygons) == 0:
raise QgsProcessingException(
self.tr('There were no polygons created.'))
total = 100.0 / len(c.polygons)
for (site, edges) in list(c.polygons.items()):
if feedback.isCanceled():
break
request = QgsFeatureRequest().setFilterFid(ptDict[ids[site]])
inFeat = next(source.getFeatures(request))
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())
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
current += 1
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.INPUT), context)
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: {0}/{1}').format(
hSpacing, vSpacing))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields(), layer.wkbType(), layer.crs(), context)
features = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
for current, f in enumerate(features):
geom = f.geometry()
geomType = geom.wkbType()
if geomType == QgsWkbTypes.Point:
points = self._gridify([geom.asPoint()], hSpacing, vSpacing)
newGeom = QgsGeometry.fromPoint(points[0])
elif geomType == QgsWkbTypes.MultiPoint:
points = self._gridify(geom.aMultiPoint(), hSpacing, vSpacing)
newGeom = QgsGeometry.fromMultiPoint(points)
elif geomType == QgsWkbTypes.LineString:
points = self._gridify(geom.asPolyline(), hSpacing, vSpacing)
if len(points) < 2:
QgsMessageLog.logMessage(
self.tr(
'Failed to gridify feature with FID {0}').format(
f.id()), self.tr('Processing'),
QgsMessageLog.INFO)
newGeom = None
else:
newGeom = QgsGeometry.fromPolyline(points)
elif geomType == QgsWkbTypes.MultiLineString:
polyline = []
for line in geom.asMultiPolyline():
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 1:
polyline.append(points)
if len(polyline) <= 0:
QgsMessageLog.logMessage(
self.tr(
'Failed to gridify feature with FID {0}').format(
f.id()), self.tr('Processing'),
QgsMessageLog.INFO)
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolyline(polyline)
elif geomType == QgsWkbTypes.Polygon:
polygon = []
for line in geom.asPolygon():
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 1:
polygon.append(points)
if len(polygon) <= 0:
QgsMessageLog.logMessage(
self.tr(
'Failed to gridify feature with FID {0}').format(
f.id()), self.tr('Processing'),
QgsMessageLog.INFO)
newGeom = None
else:
newGeom = QgsGeometry.fromPolygon(polygon)
elif geomType == QgsWkbTypes.MultiPolygon:
multipolygon = []
for polygon in geom.asMultiPolygon():
newPolygon = []
for line in polygon:
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 2:
newPolygon.append(points)
if len(newPolygon) > 0:
multipolygon.append(newPolygon)
if len(multipolygon) <= 0:
QgsMessageLog.logMessage(
self.tr(
'Failed to gridify feature with FID {0}').format(
f.id()), self.tr('Processing'),
QgsMessageLog.INFO)
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolygon(multipolygon)
if newGeom is not None:
feat = QgsFeature()
feat.setGeometry(newGeom)
feat.setAttributes(f.attributes())
writer.addFeature(feat)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, context, feedback):
layer = dataobjects.getLayerFromString(
self.getParameterValue(self.INPUT))
useField = self.getParameterValue(self.METHOD) == 1
fieldName = self.getParameterValue(self.FIELD)
f = QgsField('value', QVariant.String, '', 255)
if useField:
index = layer.fields().lookupField(fieldName)
fType = layer.fields()[index].type()
if fType in [
QVariant.Int, QVariant.UInt, QVariant.LongLong,
QVariant.ULongLong
]:
f.setType(fType)
f.setLength(20)
elif fType == QVariant.Double:
f.setType(QVariant.Double)
f.setLength(20)
f.setPrecision(6)
else:
f.setType(QVariant.String)
f.setLength(255)
fields = [
QgsField('id', QVariant.Int, '', 20), f,
QgsField('area', QVariant.Double, '', 20, 6),
QgsField('perim', QVariant.Double, '', 20, 6)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Polygon, layer.crs(), context)
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
fid = 0
val = None
features = QgsProcessingUtils.getFeatures(layer, context)
if useField:
unique = layer.uniqueValues(index)
current = 0
total = 100.0 / (QgsProcessingUtils.featureCount(layer, context) *
len(unique))
for i in unique:
first = True
hull = []
features = QgsProcessingUtils.getFeatures(layer, context)
for f in features:
idVar = f[fieldName]
if str(idVar).strip() == str(i).strip():
if first:
val = idVar
first = False
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
feedback.setProgress(int(current * total))
if len(hull) >= 3:
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([fid, val, area, perim])
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(
self.tr('Exception while computing convex hull'))
fid += 1
else:
hull = []
total = 100.0 / layer.featureCount()
features = QgsProcessingUtils.getFeatures(layer, context)
for current, f in enumerate(features):
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
feedback.setProgress(int(current * total))
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([0, 'all', area, perim])
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(
self.tr('Exception while computing convex hull'))
del writer
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
buf = self.getParameterValue(self.BUFFER)
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(layer.fields(), QgsWkbTypes.Polygon,
layer.crs(), context)
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 = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / layer.featureCount() if layer.featureCount() else 0
for current, inFeat in enumerate(features):
geom = 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()
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[0], i[1], sitenum=j) for (j,
i) in enumerate(uniqueSet)])
voronoi.voronoi(sl, c)
inFeat = QgsFeature()
current = 0
if len(c.polygons) == 0:
raise GeoAlgorithmExecutionException(
self.tr('There were no polygons created.'))
total = 100.0 / len(c.polygons)
for (site, edges) in list(c.polygons.items()):
request = QgsFeatureRequest().setFilterFid(ptDict[ids[site]])
inFeat = next(layer.getFeatures(request))
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, QgsFeatureSink.FastInsert)
current += 1
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, feedback):
layer = dataobjects.getLayerFromString(
self.getParameterValue(self.INPUT_VECTOR))
startPoint = self.getParameterValue(self.START_POINT)
strategy = self.getParameterValue(self.STRATEGY)
travelCost = self.getParameterValue(self.TRAVEL_COST)
directionFieldName = self.getParameterValue(self.DIRECTION_FIELD)
forwardValue = self.getParameterValue(self.VALUE_FORWARD)
backwardValue = self.getParameterValue(self.VALUE_BACKWARD)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
bothValue = self.getParameterValue(self.VALUE_BOTH)
defaultDirection = self.getParameterValue(self.DEFAULT_DIRECTION)
speedFieldName = self.getParameterValue(self.SPEED_FIELD)
defaultSpeed = self.getParameterValue(self.DEFAULT_SPEED)
tolerance = self.getParameterValue(self.TOLERANCE)
tmp = startPoint.split(',')
startPoint = QgsPoint(float(tmp[0]), float(tmp[1]))
directionField = -1
if directionFieldName is not None:
directionField = layer.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName is not None:
speedField = layer.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(layer, directionField, forwardValue,
backwardValue, bothValue,
defaultDirection)
distUnit = iface.mapCanvas().mapSettings().destinationCrs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(
distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField, defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(
iface.mapCanvas().mapSettings().destinationCrs(), True, tolerance)
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, [startPoint])
feedback.pushInfo(self.tr('Calculating service area...'))
graph = builder.graph()
idxStart = graph.findVertex(snappedPoints[0])
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
vertices = []
for i, v in enumerate(cost):
if v > travelCost and tree[i] != -1:
vertexId = graph.edge(tree[i]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(i)
upperBoundary = []
lowerBoundary = []
for i in vertices:
upperBoundary.append(
graph.vertex(graph.edge(tree[i]).inVertex()).point())
lowerBoundary.append(
graph.vertex(graph.edge(tree[i]).outVertex()).point())
feedback.pushInfo(self.tr('Writing results...'))
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
writer = self.getOutputFromName(self.OUTPUT_POINTS).getVectorWriter(
fields, QgsWkbTypes.MultiPoint, layer.crs())
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
writer.addFeature(feat)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
writer.addFeature(feat)
del writer
upperBoundary.append(startPoint)
lowerBoundary.append(startPoint)
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
writer = self.getOutputFromName(self.OUTPUT_POLYGON).getVectorWriter(
fields, QgsWkbTypes.Polygon, layer.crs())
geom = geomUpper.convexHull()
feat.setGeometry(geom)
feat['type'] = 'upper'
feat['start'] = startPoint.toString()
writer.addFeature(feat)
geom = geomLower.convexHull()
feat.setGeometry(geom)
feat['type'] = 'lower'
feat['start'] = startPoint.toString()
writer.addFeature(feat)
del writer
def fromMultiPointXY(mp):
try:
return QgsGeometry.fromMultiPointXY([QgsPointXY(p) for p in mp])
except AttributeError:
return QgsGeometry.fromMultiPoint(mp)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
useField = self.getParameterValue(self.METHOD) == 1
fieldName = self.getParameterValue(self.FIELD)
f = QgsField('value', QVariant.String, '', 255)
if useField:
index = layer.fieldNameIndex(fieldName)
fType = layer.pendingFields()[index].type()
if fType == QVariant.Int:
f.setType(QVariant.Int)
f.setLength(20)
elif fType == QVariant.Double:
f.setType(QVariant.Double)
f.setLength(20)
f.setPrecision(6)
else:
f.setType(QVariant.String)
f.setLength(255)
fields = [QgsField('id', QVariant.Int, '', 20),
f,
QgsField('area', QVariant.Double, '', 20, 6),
QgsField('perim', QVariant.Double, '', 20, 6)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QGis.WKBPolygon, layer.dataProvider().crs())
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
current = 0
fid = 0
val = None
features = vector.features(layer)
if useField:
unique = layer.uniqueValues(index)
total = 100.0 / (len(features) * len(unique))
for i in unique:
first = True
hull = []
features = vector.features(layer)
for f in features:
idVar = f[fieldName]
if unicode(idVar).strip() == unicode(i).strip():
if first:
val = idVar
first = False
inGeom = QgsGeometry(f.geometry())
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
progress.setPercentage(int(current * total))
if len(hull) >= 3:
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([fid, val, area, perim])
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(
self.tr('Exception while computing convex hull'))
fid += 1
else:
hull = []
total = 100.0 / float(layer.featureCount())
features = vector.features(layer)
for f in features:
inGeom = QgsGeometry(f.geometry())
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
progress.setPercentage(int(current * total))
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([0, 'all', area, perim])
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(
self.tr('Exception while computing convex hull'))
del writer
def testFromMultiPoint(self):
myMultiPoint = QgsGeometry.fromMultiPoint([
(QgsPoint(0, 0)),(QgsPoint(1, 1))])
myMessage = ('Expected:\n%s\nGot:\n%s\n' %
(QGis.WKBMultiPoint, myMultiPoint.type()))
assert myMultiPoint.wkbType() == QGis.WKBMultiPoint, myMessage
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
buf = self.parameterAsDouble(parameters, self.BUFFER, context)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
source.fields(), QgsWkbTypes.Polygon, source.sourceCrs())
outFeat = QgsFeature()
extent = source.sourceExtent()
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 = source.getFeatures()
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
geom = 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()
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[0], i[1], sitenum=j) for (j,
i) in enumerate(uniqueSet)])
voronoi.voronoi(sl, c)
inFeat = QgsFeature()
current = 0
if len(c.polygons) == 0:
raise QgsProcessingException(
self.tr('There were no polygons created.'))
total = 100.0 / len(c.polygons)
for (site, edges) in list(c.polygons.items()):
if feedback.isCanceled():
break
request = QgsFeatureRequest().setFilterFid(ptDict[ids[site]])
inFeat = next(source.getFeatures(request))
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())
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
current += 1
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
network = self.parameterAsSource(parameters, self.INPUT, context)
startPoints = self.parameterAsSource(parameters, self.START_POINTS, context)
strategy = self.parameterAsEnum(parameters, self.STRATEGY, context)
travelCost = self.parameterAsDouble(parameters, self.TRAVEL_COST, context)
directionFieldName = self.parameterAsString(parameters, self.DIRECTION_FIELD, context)
forwardValue = self.parameterAsString(parameters, self.VALUE_FORWARD, context)
backwardValue = self.parameterAsString(parameters, self.VALUE_BACKWARD, context)
bothValue = self.parameterAsString(parameters, self.VALUE_BOTH, context)
defaultDirection = self.parameterAsEnum(parameters, self.DEFAULT_DIRECTION, context)
speedFieldName = self.parameterAsString(parameters, self.SPEED_FIELD, context)
defaultSpeed = self.parameterAsDouble(parameters, self.DEFAULT_SPEED, context)
tolerance = self.parameterAsDouble(parameters, self.TOLERANCE, context)
fields = QgsFields()
fields.append(QgsField('type', QVariant.String, '', 254, 0))
fields.append(QgsField('start', QVariant.String, '', 254, 0))
feat = QgsFeature()
feat.setFields(fields)
directionField = -1
if directionFieldName:
directionField = network.fields().lookupField(directionFieldName)
speedField = -1
if speedFieldName:
speedField = network.fields().lookupField(speedFieldName)
director = QgsVectorLayerDirector(network,
directionField,
forwardValue,
backwardValue,
bothValue,
defaultDirection)
distUnit = context.project().crs().mapUnits()
multiplier = QgsUnitTypes.fromUnitToUnitFactor(distUnit, QgsUnitTypes.DistanceMeters)
if strategy == 0:
strategy = QgsNetworkDistanceStrategy()
else:
strategy = QgsNetworkSpeedStrategy(speedField,
defaultSpeed,
multiplier * 1000.0 / 3600.0)
director.addStrategy(strategy)
builder = QgsGraphBuilder(network.sourceCrs(),
True,
tolerance)
feedback.pushInfo(self.tr('Loading start points...'))
request = QgsFeatureRequest()
request.setFlags(request.flags() ^ QgsFeatureRequest.SubsetOfAttributes)
request.setDestinationCrs(network.sourceCrs())
features = startPoints.getFeatures(request)
total = 100.0 / startPoints.featureCount() if startPoints.featureCount() else 0
points = []
for current, f in enumerate(features):
if feedback.isCanceled():
break
points.append(f.geometry().asPoint())
feedback.setProgress(int(current * total))
feedback.pushInfo(self.tr('Building graph...'))
snappedPoints = director.makeGraph(builder, points, feedback)
feedback.pushInfo(self.tr('Calculating service areas...'))
graph = builder.graph()
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.MultiPoint, network.sourceCrs())
vertices = []
upperBoundary = []
lowerBoundary = []
total = 100.0 / len(snappedPoints) if snappedPoints else 1
for i, p in enumerate(snappedPoints):
if feedback.isCanceled():
break
idxStart = graph.findVertex(snappedPoints[i])
origPoint = points[i].toString()
tree, cost = QgsGraphAnalyzer.dijkstra(graph, idxStart, 0)
for j, v in enumerate(cost):
if v > travelCost and tree[j] != -1:
vertexId = graph.edge(tree[j]).outVertex()
if cost[vertexId] <= travelCost:
vertices.append(j)
for j in vertices:
upperBoundary.append(graph.vertex(graph.edge(tree[j]).inVertex()).point())
lowerBoundary.append(graph.vertex(graph.edge(tree[j]).outVertex()).point())
geomUpper = QgsGeometry.fromMultiPoint(upperBoundary)
geomLower = QgsGeometry.fromMultiPoint(lowerBoundary)
feat.setGeometry(geomUpper)
feat['type'] = 'upper'
feat['start'] = origPoint
sink.addFeature(feat, QgsFeatureSink.FastInsert)
feat.setGeometry(geomLower)
feat['type'] = 'lower'
feat['start'] = origPoint
sink.addFeature(feat, QgsFeatureSink.FastInsert)
vertices[:] = []
upperBoundary[:] = []
lowerBoundary[:] = []
feedback.setProgress(int(i * total))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(
self.INPUT))
useField = self.getParameterValue(self.METHOD) == 1
fieldName = self.getParameterValue(self.FIELD)
f = QgsField('value', QVariant.String, '', 255)
if useField:
index = layer.fieldNameIndex(fieldName)
fType = layer.pendingFields()[index].type()
if fType == QVariant.Int:
f.setType(QVariant.Int)
f.setLength(20)
elif fType == QVariant.Double:
f.setType(QVariant.Double)
f.setLength(20)
f.setPrecision(6)
else:
f.setType(QVariant.String)
f.setLength(255)
fields = [
QgsField('id', QVariant.Int, '', 20), f,
QgsField('area', QVariant.Double, '', 20, 6),
QgsField('perim', QVariant.Double, '', 20, 6)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QGis.WKBPolygon,
layer.dataProvider().crs())
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
current = 0
fid = 0
val = None
features = vector.features(layer)
if useField:
unique = layer.uniqueValues(index)
total = 100.0 / (len(features) * len(unique))
for i in unique:
first = True
hull = []
features = vector.features(layer)
for f in features:
idVar = f[fieldName]
if unicode(idVar).strip() == unicode(i).strip():
if first:
val = idVar
first = False
inGeom = QgsGeometry(f.geometry())
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
progress.setPercentage(int(current * total))
if len(hull) >= 3:
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([fid, val, area, perim])
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(
self.tr('Exception while computing convex hull'))
fid += 1
else:
hull = []
total = 100.0 / float(layer.featureCount())
features = vector.features(layer)
for f in features:
inGeom = QgsGeometry(f.geometry())
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
progress.setPercentage(int(current * total))
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([0, 'all', area, perim])
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(
self.tr('Exception while computing convex hull'))
del writer
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: %s/%s' % (hSpacing, vSpacing)))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
layer.fields(), layer.wkbType(), layer.crs())
features = vector.features(layer)
total = 100.0 / len(features)
for current, f in enumerate(features):
geom = f.geometry()
geomType = geom.wkbType()
if geomType == QgsWkbTypes.Point:
points = self._gridify([geom.asPoint()], hSpacing, vSpacing)
newGeom = QgsGeometry.fromPoint(points[0])
elif geomType == QgsWkbTypes.MultiPoint:
points = self._gridify(geom.aMultiPoint(), hSpacing, vSpacing)
newGeom = QgsGeometry.fromMultiPoint(points)
elif geomType == QgsWkbTypes.LineString:
points = self._gridify(geom.asPolyline(), hSpacing, vSpacing)
if len(points) < 2:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Failed to gridify feature with FID %s' % f.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromPolyline(points)
elif geomType == QgsWkbTypes.MultiLineString:
polyline = []
for line in geom.asMultiPolyline():
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 1:
polyline.append(points)
if len(polyline) <= 0:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Failed to gridify feature with FID %s' % f.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolyline(polyline)
elif geomType == QgsWkbTypes.Polygon:
polygon = []
for line in geom.asPolygon():
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 1:
polygon.append(points)
if len(polygon) <= 0:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Failed to gridify feature with FID %s' % f.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromPolygon(polygon)
elif geomType == QgsWkbTypes.MultiPolygon:
multipolygon = []
for polygon in geom.asMultiPolygon():
newPolygon = []
for line in polygon:
points = self._gridify(line, hSpacing, vSpacing)
if len(points) > 2:
newPolygon.append(points)
if len(newPolygon) > 0:
multipolygon.append(newPolygon)
if len(multipolygon) <= 0:
ProcessingLog.addToLog(ProcessingLog.LOG_INFO,
self.tr('Failed to gridify feature with FID %s' % f.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolygon(multipolygon)
if newGeom is not None:
feat = QgsFeature()
feat.setGeometry(newGeom)
feat.setAttributes(f.attributes())
writer.addFeature(feat)
progress.setPercentage(int(current * total))
del writer
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT), context)
useField = self.getParameterValue(self.METHOD) == 1
fieldName = self.getParameterValue(self.FIELD)
f = QgsField('value', QVariant.String, '', 255)
if useField:
index = layer.fields().lookupField(fieldName)
fType = layer.fields()[index].type()
if fType in [QVariant.Int, QVariant.UInt, QVariant.LongLong, QVariant.ULongLong]:
f.setType(fType)
f.setLength(20)
elif fType == QVariant.Double:
f.setType(QVariant.Double)
f.setLength(20)
f.setPrecision(6)
else:
f.setType(QVariant.String)
f.setLength(255)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 20))
fields.append(f)
fields.append(QgsField('area', QVariant.Double, '', 20, 6))
fields.append(QgsField('perim', QVariant.Double, '', 20, 6))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs(), context)
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
fid = 0
val = None
features = QgsProcessingUtils.getFeatures(layer, context)
if useField:
unique = layer.uniqueValues(index)
current = 0
total = 100.0 / (layer.featureCount() * len(unique)) if layer.featureCount() else 1
for i in unique:
first = True
hull = []
features = QgsProcessingUtils.getFeatures(layer, context)
for f in features:
idVar = f[fieldName]
if str(idVar).strip() == str(i).strip():
if first:
val = idVar
first = False
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
feedback.setProgress(int(current * total))
if len(hull) >= 3:
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([fid, val, area, perim])
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
raise GeoAlgorithmExecutionException(
self.tr('Exception while computing convex hull'))
fid += 1
else:
hull = []
total = 100.0 / layer.featureCount() if layer.featureCount() else 1
features = QgsProcessingUtils.getFeatures(layer, context)
for current, f in enumerate(features):
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
feedback.setProgress(int(current * total))
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([0, 'all', area, perim])
writer.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
raise GeoAlgorithmExecutionException(
self.tr('Exception while computing convex hull'))
del writer
def _convex_hull(self, graph, builder):
points = [builder.node_to_point(n) for n in graph.nodes]
multipoint = QgsGeometry.fromMultiPoint(points)
return multipoint.convexHull().buffer(0.5, 8)
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
useField = bool(fieldName)
field_index = None
f = QgsField('value', QVariant.String, '', 255)
if useField:
field_index = source.fields().lookupField(fieldName)
fType = source.fields()[field_index].type()
if fType in [
QVariant.Int, QVariant.UInt, QVariant.LongLong,
QVariant.ULongLong
]:
f.setType(fType)
f.setLength(20)
elif fType == QVariant.Double:
f.setType(QVariant.Double)
f.setLength(20)
f.setPrecision(6)
else:
f.setType(QVariant.String)
f.setLength(255)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 20))
fields.append(f)
fields.append(QgsField('area', QVariant.Double, '', 20, 6))
fields.append(QgsField('perim', QVariant.Double, '', 20, 6))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Polygon,
source.sourceCrs())
outFeat = QgsFeature()
outGeom = QgsGeometry()
fid = 0
val = None
if useField:
unique = source.uniqueValues(field_index)
current = 0
total = 100.0 / (source.featureCount() *
len(unique)) if source.featureCount() else 1
for i in unique:
if feedback.isCanceled():
break
first = True
hull = []
features = source.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes([field_index]))
for f in features:
if feedback.isCanceled():
break
idVar = f.attributes()[field_index]
if str(idVar).strip() == str(i).strip():
if first:
val = idVar
first = False
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
feedback.setProgress(int(current * total))
if len(hull) >= 3:
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
if outGeom:
area = outGeom.geometry().area()
perim = outGeom.geometry().perimeter()
else:
area = NULL
perim = NULL
outFeat.setGeometry(outGeom)
outFeat.setAttributes([fid, val, area, perim])
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
raise QgsProcessingException(
self.tr('Exception while computing convex hull'))
fid += 1
else:
hull = []
total = 100.0 / source.featureCount() if source.featureCount(
) else 1
features = source.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes([]))
for current, f in enumerate(features):
if feedback.isCanceled():
break
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
feedback.setProgress(int(current * total))
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
if outGeom:
area = outGeom.geometry().area()
perim = outGeom.geometry().perimeter()
else:
area = NULL
perim = NULL
outFeat.setGeometry(outGeom)
outFeat.setAttributes([0, 'all', area, perim])
sink.addFeature(outFeat, QgsFeatureSink.FastInsert)
except:
raise QgsProcessingException(
self.tr('Exception while computing convex hull'))
return {self.OUTPUT: dest_id}
def processFeature(self, feature, feedback):
if feature.hasGeometry():
geom = feature.geometry()
geomType = QgsWkbTypes.flatType(geom.wkbType())
newGeom = None
if geomType == QgsWkbTypes.Point:
points = self._gridify([geom.asPoint()], self.h_spacing, self.v_spacing)
newGeom = QgsGeometry.fromPoint(points[0])
elif geomType == QgsWkbTypes.MultiPoint:
points = self._gridify(geom.asMultiPoint(), self.h_spacing, self.v_spacing)
newGeom = QgsGeometry.fromMultiPoint(points)
elif geomType == QgsWkbTypes.LineString:
points = self._gridify(geom.asPolyline(), self.h_spacing, self.v_spacing)
if len(points) < 2:
feedback.reportError(self.tr('Failed to gridify feature with FID {0}').format(feature.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromPolyline(points)
elif geomType == QgsWkbTypes.MultiLineString:
polyline = []
for line in geom.asMultiPolyline():
points = self._gridify(line, self.h_spacing, self.v_spacing)
if len(points) > 1:
polyline.append(points)
if len(polyline) <= 0:
feedback.reportError(self.tr('Failed to gridify feature with FID {0}').format(feature.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolyline(polyline)
elif geomType == QgsWkbTypes.Polygon:
polygon = []
for line in geom.asPolygon():
points = self._gridify(line, self.h_spacing, self.v_spacing)
if len(points) > 1:
polygon.append(points)
if len(polygon) <= 0:
feedback.reportError(self.tr('Failed to gridify feature with FID {0}').format(feature.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromPolygon(polygon)
elif geomType == QgsWkbTypes.MultiPolygon:
multipolygon = []
for polygon in geom.asMultiPolygon():
newPolygon = []
for line in polygon:
points = self._gridify(line, self.h_spacing, self.v_spacing)
if len(points) > 2:
newPolygon.append(points)
if len(newPolygon) > 0:
multipolygon.append(newPolygon)
if len(multipolygon) <= 0:
feedback.reportError(self.tr('Failed to gridify feature with FID {0}').format(feature.id()))
newGeom = None
else:
newGeom = QgsGeometry.fromMultiPolygon(multipolygon)
if newGeom is not None:
feature.setGeometry(newGeom)
else:
feature.clearGeometry()
return feature
def addAnyFeature(self, featureType, mapPointList, attributes, layer):
geometryType = FeatureType.toGeometryType(featureType)
# points: bail out if there is not exactly one vertex
if (geometryType == QGis.Point and len(mapPointList) != 1):
return False
# segments: bail out if there are not exactly two vertices
if (featureType == FeatureType.Segment and len(mapPointList) != 2):
return False
# lines: bail out if there are not at least two vertices
if (featureType == FeatureType.Line and len(mapPointList) < 2):
return False
# polygons: bail out if there are not at least three vertices
if (geometryType == QGis.Polygon and len(mapPointList) < 3):
return False
if (geometryType != layer.geometryType()):
self.messageEmitted.emit(
self.tr('Cannot add feature: Layer and Feature geometry type mismatch'), QgsMessageBar.CRITICAL)
return False
if (layer.type() != QgsMapLayer.VectorLayer):
self.messageEmitted.emit(
self.tr('Cannot add feature: Current layer not a vector layer'), QgsMessageBar.CRITICAL)
return False
if (not layer.isEditable()):
self.messageEmitted.emit(self.tr('Cannot add feature: Current layer not editable'), QgsMessageBar.CRITICAL)
return False
provider = layer.dataProvider()
if (not (provider.capabilities() & QgsVectorDataProvider.AddFeatures)):
self.messageEmitted.emit(
self.tr('Cannot add feature: Data provider does not support the addition of features.'),
QgsMessageBar.CRITICAL)
return False
multiType = QGis.isMultiType(layer.wkbType())
layerPoints = self._layerPoints(mapPointList, layer)
feature = QgsFeature(layer.pendingFields(), 0)
geometry = None
if (geometryType == QGis.Point):
if multiType:
geometry = QgsGeometry.fromMultiPoint([layerPoints[0]])
else:
geometry = QgsGeometry(layerPoints[0])
elif (geometryType == QGis.Line):
if multiType:
geometry = QgsGeometry.fromMultiPolyline([layerPoints])
else:
geometry = QgsGeometry.fromPolyline(layerPoints)
elif (geometryType == QGis.Polygon):
if multiType:
geometry = QgsGeometry.fromMultiPolygon([layerPoints])
else:
geometry = QgsGeometry.fromPolygon([layerPoints])
else:
self.messageEmitted.emit(self.tr('Cannot add feature. Unknown geometry type'), QgsMessageBar.CRITICAL)
return False
if (geometry is None):
self.messageEmitted.emit(self.tr('Cannot add feature. Invalid geometry'), QgsMessageBar.CRITICAL)
return False
feature.setGeometry(geometry)
if (geometryType == QGis.Polygon):
avoidIntersectionsReturn = feature.geometry().avoidIntersections()
if (avoidIntersectionsReturn == 1):
# not a polygon type. Impossible to get there
pass
elif (avoidIntersectionsReturn == 3):
self.messageEmitted.emit(
self.tr('An error was reported during intersection removal'), QgsMessageBar.CRITICAL)
if (not feature.geometry().asWkb()): # avoid intersection might have removed the whole geometry
reason = ''
if (avoidIntersectionsReturn != 2):
reason = self.tr('The feature cannot be added because it\'s geometry is empty')
else:
reason = self.tr(
'The feature cannot be added because it\'s geometry collapsed due to intersection avoidance')
self.messageEmitted.emit(reason, QgsMessageBar.CRITICAL)
return False
featureSaved = self._addFeatureAction(feature, attributes, layer, False)
if (featureSaved and geometryType != QGis.Point):
# add points to other features to keep topology up-to-date
topologicalEditing = Snapping.topologicalEditing()
# use always topological editing for avoidIntersection.
# Otherwise, no way to guarantee the geometries don't have a small gap in between.
intersectionLayers = Snapping.intersectionLayers()
avoidIntersection = len(intersectionLayers)
if (avoidIntersection): # try to add topological points also to background layers
for intersectionLayer in intersectionLayers:
vl = QgsMapLayerRegistry.instance().mapLayer(str(intersectionLayer))
# can only add topological points if background layer is editable...
if (vl is not None and vl.geometryType() == QGis.Polygon and vl.isEditable()):
vl.addTopologicalPoints(feature.geometry())
elif (topologicalEditing):
self._layer.addTopologicalPoints(feature.geometry())
self.canvas().refresh()
return True
def on_btnRun_clicked(self):
if self.inputfile == '':
QMessageBox.critical(self,'Map Creator',
'Please specify input coordinate file.')
return
if self.outputfile == '':
QMessageBox.critical(self,'Map Creator',
'Please specify output shapefile.')
return
self.setCursor(Qt.WaitCursor)
#Open coordinate input file
f = open(self.inputfile, 'r')
lines = f.readlines()
f.close()
header = lines[0].split(',')[0]
totfeat = len(lines) - 1
lines.pop(0)
lines.reverse()
#Create vector layer
basename = os.path.basename(self.outputfile)
vlayer = QgsVectorLayer("Polygon", basename, "memory")
vprovider = vlayer.dataProvider()
fld = QgsField(header,QVariant.String)
flds = QgsFields()
flds.append(fld)
vprovider.addAttributes([fld])
vlayer.startEditing()
hull = []
for cnt, line in enumerate(lines):
line = line.rstrip().split(',')
numcoords = int((len(line) - 1) / 2)
hull[:] = []
geom = QgsGeometry()
feat = QgsFeature()
feat.setFields(flds)
for i in range(numcoords):
hull.append(QgsPoint(float(line[i*2+1]),float(line[i*2+2])))
geom = geom.fromMultiPoint(hull)
geom = geom.convexHull()
feat.setGeometry(geom)
feat.setAttribute(header,str(line[0]))
result = vlayer.addFeature(feat)
if not result:
self.setCursor(Qt.ArrowCursor)
QMessageBox.critical(self,'Map Creator', 'Processing error.')
return
self.ui.ProgressBar.setValue(float(cnt+1)/float(totfeat) * 100.0)
QApplication.processEvents()
vlayer.commitChanges()
vlayer.updateExtents()
#Write the output shapefile
if os.path.exists(self.outputfile):
QgsVectorFileWriter.deleteShapeFile(self.outputfile)
result = QgsVectorFileWriter.writeAsVectorFormat(vlayer,
self.outputfile,
'utf-8',
vlayer.crs())
if result != QgsVectorFileWriter.NoError:
QMessageBox.critical(self,'Map Creator','Error creating shapefile.')
else: #Ask to add shapfile to map
name = QFileInfo(self.outputfile).completeBaseName()
result = QMessageBox.question(self,'Map Creator',
'Add shapefile to map?',
QMessageBox.Yes,
QMessageBox.No)
if result == QMessageBox.Yes:
self.iface.addVectorLayer(self.outputfile, name, 'ogr')
self.setCursor(Qt.ArrowCursor)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
useField = self.getParameterValue(self.METHOD) == 1
fieldName = self.getParameterValue(self.FIELD)
f = QgsField("value", QVariant.String, "", 255)
if useField:
index = layer.fields().lookupField(fieldName)
fType = layer.fields()[index].type()
if fType in [QVariant.Int, QVariant.UInt, QVariant.LongLong, QVariant.ULongLong]:
f.setType(fType)
f.setLength(20)
elif fType == QVariant.Double:
f.setType(QVariant.Double)
f.setLength(20)
f.setPrecision(6)
else:
f.setType(QVariant.String)
f.setLength(255)
fields = [
QgsField("id", QVariant.Int, "", 20),
f,
QgsField("area", QVariant.Double, "", 20, 6),
QgsField("perim", QVariant.Double, "", 20, 6),
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Polygon, layer.crs())
outFeat = QgsFeature()
inGeom = QgsGeometry()
outGeom = QgsGeometry()
fid = 0
val = None
features = vector.features(layer)
if useField:
unique = layer.uniqueValues(index)
current = 0
total = 100.0 / (len(features) * len(unique))
for i in unique:
first = True
hull = []
features = vector.features(layer)
for f in features:
idVar = f[fieldName]
if str(idVar).strip() == str(i).strip():
if first:
val = idVar
first = False
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
current += 1
progress.setPercentage(int(current * total))
if len(hull) >= 3:
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([fid, val, area, perim])
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(self.tr("Exception while computing convex hull"))
fid += 1
else:
hull = []
total = 100.0 / layer.featureCount()
features = vector.features(layer)
for current, f in enumerate(features):
inGeom = f.geometry()
points = vector.extractPoints(inGeom)
hull.extend(points)
progress.setPercentage(int(current * total))
tmpGeom = QgsGeometry(outGeom.fromMultiPoint(hull))
try:
outGeom = tmpGeom.convexHull()
(area, perim) = vector.simpleMeasure(outGeom)
outFeat.setGeometry(outGeom)
outFeat.setAttributes([0, "all", area, perim])
writer.addFeature(outFeat)
except:
raise GeoAlgorithmExecutionException(self.tr("Exception while computing convex hull"))
del writer
