def canvasPressEvent(self, mouseEvent):
self.rubber.reset()
pos = mouseEvent.pos()
features = self.getFeatures(pos)
nFeat = len(features)
if nFeat < 2:
layerNames = " , ".join([feature.layer.name() for feature in features])
self.iface.messageBar().pushMessage("Intersect It", "You need 2 features to proceed a simple intersection."
" %u given (%s)" % (nFeat, layerNames), QgsMessageBar.WARNING, 3)
return
intersectionP = self.intersection(features, pos)
if intersectionP == QgsPoint(0,0):
self.iface.messageBar().pushMessage("Intersect It", "Objects do not intersect.", QgsMessageBar.WARNING, 2)
return
layer = self.checkLayer()
if layer is None:
return
f = QgsFeature()
initFields = layer.dataProvider().fields()
f.setFields(initFields)
f.initAttributes(initFields.size())
f.setGeometry(QgsGeometry().fromPoint(intersectionP))
layer.editBuffer().addFeature(f)
layer.triggerRepaint()
def _create_points(self):
"""Create points for testing"""
point_layer = QgsVectorLayer('Point?crs=EPSG:4326', 'points', 'memory')
point_provider = point_layer.dataProvider()
point_provider.addAttributes([QgsField('X', QVariant.Double)])
point_provider.addAttributes([QgsField('Y', QVariant.Double)])
x_index = point_provider.fieldNameIndex('X')
y_index = point_provider.fieldNameIndex('Y')
point_layer.startEditing()
for x in [10.0, 20.0, 30.0]:
for y in [10.0, 20.0, 30.0]:
feature = QgsFeature()
feature.initAttributes(2)
feature.setAttribute(x_index, x)
feature.setAttribute(y_index, y)
# noinspection PyCallByClass
geom = QgsGeometry.fromPoint(QgsPoint(x, y))
feature.setGeometry(geom)
_ = point_layer.dataProvider().addFeatures([feature])
point_layer.commitChanges()
return point_layer
def processAlgorithm(self, parameters, context, feedback):
spacing = self.parameterAsDouble(parameters, self.SPACING, context)
inset = self.parameterAsDouble(parameters, self.INSET, context)
randomize = self.parameterAsBool(parameters, self.RANDOMIZE, context)
isSpacing = self.parameterAsBool(parameters, self.IS_SPACING, context)
crs = self.parameterAsCrs(parameters, self.CRS, context)
extent = self.parameterAsExtent(parameters, self.EXTENT, context, crs)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Point, crs)
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(extent_geom.constGet())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if feedback.isCanceled():
break
if randomize:
geom = QgsGeometry().fromPointXY(QgsPointXY(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPointXY(QgsPointXY(x, y))
if extent_engine.intersects(geom.constGet()):
f.setAttribute('id', count)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
return {self.OUTPUT: dest_id}
def createGeometry(self, geom):
geom = self.reprojectRubberBand(geom)
if geom :
layer = self.canvas.currentLayer()
feature = QgsFeature()
fields = layer.pendingFields()
feature.setGeometry(geom)
feature.initAttributes(fields.count())
provider = layer.dataProvider()
for i in range(fields.count()):
feature.setAttribute(i, provider.defaultValue(i))
form = QgsAttributeDialog(layer, feature, False)
form.setMode(QgsAttributeForm.AddFeatureMode)
formSuppress = layer.editFormConfig().suppress()
if formSuppress == QgsEditFormConfig.SuppressDefault:
if self.getSuppressOptions(): #this is calculated every time because user can switch options while using tool
layer.addFeature(feature, True)
else:
if not form.dialog().exec_():
feature.setAttributes(form.feature().attributes())
elif formSuppress == QgsEditFormConfig.SuppressOff:
if not form.dialog().exec_():
feature.setAttributes(form.feature().attributes())
else:
layer.addFeature(feature, True)
layer.endEditCommand()
self.canvas.refresh()
self.initVariable()
def processAlgorithm(self, feedback):
extent = str(self.getParameterValue(self.EXTENT)).split(',')
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
extent = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(extent_geom.geometry())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(QgsPoint(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPoint(QgsPoint(x, y))
if extent_engine.intersects(geom.geometry()):
f.setAttribute('id', count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
del writer
def populate_qlayer(self):
layer=self.qlayer
# shouldn't be necessary
layer.dataProvider().deleteFeatures(layer.allFeatureIds())
# takes an existing line memory layer, adds in nodes from g
feats=[]
valid=[]
for j in self.grid.valid_edge_iter():
geom=self.edge_geometry(j)
valid.append(j)
feat = QgsFeature()
feat.initAttributes(len(self.e_attrs))
for idx,eattr in enumerate(self.e_attrs):
name=eattr.name()
typecode=eattr.type()
if name=='edge_id':
feat.setAttribute(idx,j)
elif name=='c0':
feat.setAttribute(idx,int(self.grid.edges['cells'][j,0]))
elif name=='c1':
feat.setAttribute(idx,int(self.grid.edges['cells'][j,1]))
elif typecode==2: # integer
feat.setAttribute(idx,int(self.grid.edges[name][j]))
elif typecode==6: # double
feat.setAttribute(idx,float(self.grid.edges[name][j]))
else:
continue
# QGIS doesn't know about numpy types
# feat.setAttribute(3,int(self.grid.edges['mark'][j]))
feat.setGeometry(geom)
feats.append(feat)
(res, outFeats) = layer.dataProvider().addFeatures(feats)
self.grid.edges['feat_id'][valid]=[f.id() for f in outFeats]
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context)
bbox = source.sourceExtent()
sourceIndex = QgsSpatialIndex(source, feedback)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Point, source.sourceCrs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
ids = sourceIndex.intersects(geom.buffer(5, 5).boundingBox())
if len(ids) > 0 and \
vector.checkMinDistance(p, index, minDistance, points):
request = QgsFeatureRequest().setFilterFids(ids).setSubsetOfAttributes([])
for f in source.getFeatures(request):
if feedback.isCanceled():
break
tmpGeom = f.geometry()
if geom.within(tmpGeom):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(self.tr('Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def pixels_to_points(
raster,
threshold_min=0.0,
threshold_max=float('inf'),
field_name='value'):
"""
Convert raster to points.
Areas (pixels) with threshold_min < pixel_values < threshold_max will be
converted to point layer.
:param raster: Raster layer
:type raster: QgsRasterLayer
:param threshold_min: Value that splits raster to flooded or not flooded.
:type threshold_min: float
:param threshold_max: Value that splits raster to flooded or not flooded.
:type threshold_max: float
:param field_name: Field name to store pixel value.
:type field_name: string
:returns: Point layer of pixels
:rtype: QgsVectorLayer
"""
if raster.bandCount() != 1:
msg = "Current version allows using of one-band raster only"
raise NotImplementedError(msg)
extent = raster.extent()
width, height = raster.width(), raster.height()
provider = raster.dataProvider()
block = provider.block(1, extent, width, height)
# Create points
crs = raster.crs().toWkt()
point_layer = QgsVectorLayer('Point?crs=' + crs, 'pixels', 'memory')
point_provider = point_layer.dataProvider()
point_provider.addAttributes([QgsField(field_name, QVariant.Double)])
field_index = point_provider.fieldNameIndex(field_name)
attribute_count = 1
point_layer.startEditing()
for row in range(height):
for col in range(width):
value = block.value(row, col)
x, y = _get_pixel_coordinates(extent, width, height, row, col)
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
geom = QgsGeometry.fromPoint(QgsPoint(x, y))
if threshold_min < value < threshold_max:
feature = QgsFeature()
feature.initAttributes(attribute_count)
feature.setAttribute(field_index, value)
feature.setGeometry(geom)
_ = point_layer.dataProvider().addFeatures([feature])
point_layer.commitChanges()
return point_layer
def test_setAttribute(self):
feat = QgsFeature()
feat.initAttributes(1)
with self.assertRaises(KeyError):
feat.setAttribute(-1, 5)
with self.assertRaises(KeyError):
feat.setAttribute(10, 5)
self.assertTrue(feat.setAttribute(0, 5))
def processAlgorithm(self, progress):
extent = self.getParameterValue(self.EXTENT).split(',')
xSpace = self.getParameterValue(self.STEP_X)
ySpace = self.getParameterValue(self.STEP_Y)
bbox = QgsRectangle(
float(extent[0]), float(extent[2]), float(extent[1]),
float(extent[3]))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
fields.append(QgsField('xmin', QVariant.Double, '', 24, 15))
fields.append(QgsField('xmax', QVariant.Double, '', 24, 15))
fields.append(QgsField('ymin', QVariant.Double, '', 24, 15))
fields.append(QgsField('ymax', QVariant.Double, '', 24, 15))
fieldCount = 5
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Polygon, mapCRS)
feat = QgsFeature()
feat.initAttributes(fieldCount)
feat.setFields(fields)
geom = QgsGeometry()
idVar = 0
# counters for progressbar - update every 5%
count = 0
count_max = (bbox.yMaximum() - bbox.yMinimum()) / ySpace
count_update = count_max * 0.05
y = bbox.yMaximum()
while y >= bbox.yMinimum():
x = bbox.xMinimum()
while x <= bbox.xMaximum():
pt1 = QgsPoint(x, y)
pt2 = QgsPoint(x + xSpace, y)
pt3 = QgsPoint(x + xSpace, y - ySpace)
pt4 = QgsPoint(x, y - ySpace)
pt5 = QgsPoint(x, y)
polygon = [[pt1, pt2, pt3, pt4, pt5]]
feat.setGeometry(geom.fromPolygon(polygon))
feat.setAttribute(0, idVar)
feat.setAttribute(1, x)
feat.setAttribute(2, x + xSpace)
feat.setAttribute(3, y - ySpace)
feat.setAttribute(4, y)
writer.addFeature(feat)
idVar += 1
x = x + xSpace
y = y - ySpace
count += 1
if int(math.fmod(count, count_update)) == 0:
progress.setPercentage(int(count / count_max * 100))
del writer
def processAlgorithm(self, feedback):
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
extent = str(self.getParameterValue(self.EXTENT)).split(',')
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
extent = QgsGeometry().fromRect(
QgsRectangle(xMin, yMin, xMax, yMax))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = xMin + (xMax - xMin) * random.random()
ry = yMin + (yMax - yMin) * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(extent) and \
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
feedback.setProgress(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 randomize(self, inLayer, outPath, minimum, design, value):
outFeat = QgsFeature()
outFeat.initAttributes(1)
if design == self.tr("unstratified"):
ext = inLayer.extent()
if inLayer.type() == QgsMapLayer.RasterLayer:
points = self.simpleRandom(
int(value), ext, ext.xMinimum(),
ext.xMaximum(), ext.yMinimum(), ext.yMaximum())
else:
points = self.vectorRandom(
int(value), inLayer,
ext.xMinimum(), ext.xMaximum(), ext.yMinimum(), ext.yMaximum())
else:
points, featErrors = self.loopThruPolygons(inLayer, value, design)
if featErrors:
if len(featErrors) >= 10:
err_msg = "Too many features couldn't be calculated due to conversion error. "
err_msg += "Please check out message log for more info."
msgLogInstance = QgsMessageLog.instance()
msgLogInstance.logMessage("WARNING - fTools: " + self.tr("Random Points"))
msgLogInstance.logMessage("The following feature ids should be checked.")
for feat in featErrors:
msgLogInstance.logMessage("Feature id: %d" % feat.id())
msgLogInstance.logMessage("End of features to be checked.")
else:
features_ids = []
for feat in featErrors:
features_ids.append(unicode(feat.id()))
erroneous_ids = ', '.join(features_ids)
err_msg = "The following features IDs couldn't be calculated due to conversion error: %s" % erroneous_ids
self.iface.messageBar().pushMessage("Errors", err_msg)
if len(points):
crs = self.iface.mapCanvas().mapRenderer().destinationCrs()
if not crs.isValid():
crs = None
fields = QgsFields()
fields.append(QgsField("ID", QVariant.Int))
outFeat.setFields(fields)
check = QFile(self.shapefileName)
if check.exists():
if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName):
return
writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPoint, crs)
idVar = 0
count = 70.00
add = (100.00 - 70.00) / len(points)
for i in points:
outFeat.setGeometry(i)
outFeat.setAttribute(0, idVar)
writer.addFeature(outFeat)
idVar = idVar + 1
count = count + add
self.progressBar.setValue(count)
del writer
return True
return False
def legend_test(self):
self.mAtlasMap.setAtlasDriven(True)
self.mAtlasMap.setAtlasScalingMode(QgsComposerMap.Auto)
self.mAtlasMap.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer("Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPoint(QgsPointXY(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPoint(QgsPointXY(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRenderer("attr", [QgsRendererCategory(1, QgsMarkerSymbol.createSimple({"color": "255,0,0"}), "red"),
QgsRendererCategory(2, QgsMarkerSymbol.createSimple({"color": "0,0,255"}), "blue")])
ptLayer.setRenderer(r)
QgsProject.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.layers
layers = [ptLayer] + layers
self.mAtlasMap.setLayers(layers)
self.mOverview.setLayers(layers)
# add a legend
legend = QgsComposerLegend(self.mComposition)
legend.moveBy(200, 100)
# sets the legend filter parameter
legend.setComposerMap(self.mAtlasMap)
legend.setLegendFilterOutAtlas(True)
self.mComposition.addComposerLegend(legend)
self.mAtlas.beginRender()
self.mAtlas.prepareForFeature(0)
self.mLabel1.adjustSizeToText()
checker = QgsCompositionChecker('atlas_legend', self.mComposition)
myTestResult, myMessage = checker.testComposition()
assert myTestResult
self.mAtlas.endRender()
# restore state
self.mAtlasMap.setLayers([layers[1]])
self.mComposition.removeComposerItem(legend)
QgsProject.instance().removeMapLayer(ptLayer.id())
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.VECTOR))
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
bbox = layer.extent()
idxLayer = vector.spatialindex(layer)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, layer.crs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
ids = idxLayer.intersects(geom.buffer(5, 5).boundingBox())
if len(ids) > 0 and \
vector.checkMinDistance(pnt, index, minDistance, points):
for i in ids:
f = next(layer.getFeatures(request.setFilterFid(i)))
tmpGeom = f.geometry()
if geom.within(tmpGeom):
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 test_CreateFeature(self):
feat = QgsFeature()
feat.initAttributes(1)
feat.setAttribute(0, "text")
feat.setGeometry(QgsGeometry.fromPoint(QgsPoint(123, 456)))
myId = feat.id()
myExpectedId = 0
myMessage = "\nExpected: %s\nGot: %s" % (myExpectedId, myId)
assert myId == myExpectedId, myMessage
def processAlgorithm(self, progress):
extent = str(self.getParameterValue(self.EXTENT)).split(",")
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
extent = QgsRectangle(float(extent[0]), float(extent[2]), float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField("id", QVariant.Int, "", 10, 0))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QGis.WKBPoint, mapCRS)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.00 / (area / pSpacing)
y = extent.yMaximum() - inset
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(
QgsPoint(
uniform(x - (pSpacing / 2.0), x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0), y + (pSpacing / 2.0)),
)
)
else:
geom = QgsGeometry().fromPoint(QgsPoint(x, y))
if geom.intersects(extent):
f.setAttribute("id", count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
progress.setPercentage(int(count * total))
y = y - pSpacing
del writer
def test_DeleteAttribute(self):
feat = QgsFeature()
feat.initAttributes(3)
feat[0] = "text1"
feat[1] = "text2"
feat[2] = "text3"
feat.deleteAttribute(1)
myAttrs = [feat[0], feat[1]]
myExpectedAttrs = ["text1", "text3"]
myMessage = "\nExpected: %s\nGot: %s" % (str(myExpectedAttrs), str(myAttrs))
assert myAttrs == myExpectedAttrs, myMessage
def test_DeleteAttribute(self):
feat = QgsFeature()
feat.initAttributes(3)
feat[0] = QVariant("text1")
feat[1] = QVariant("text2")
feat[2] = QVariant("text3")
feat.deleteAttribute(1)
myAttrs = [ str(feat[0].toString()), str(feat[1].toString()) ]
myExpectedAttrs = [ "text1", "text3" ]
myMessage = '\nExpected: %s\nGot: %s' % (str(myExpectedAttrs), str(myAttrs))
assert myAttrs == myExpectedAttrs, myMessage
def processAlgorithm(self, parameters, context, feedback):
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE, context)
crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context, crs)
extent = QgsGeometry().fromRect(bbox)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, QgsWkbTypes.Point, crs)
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
if geom.within(extent) and \
vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.addFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(self.tr('Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, progress):
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
extent = unicode(self.getParameterValue(self.EXTENT)).split(',')
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
extent = QgsGeometry().fromRect(
QgsRectangle(xMin, yMin, xMax, yMax))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QGis.WKBPoint, mapCRS)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount > 0 else 1
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = xMin + (xMax - xMin) * random.random()
ry = yMin + (yMax - yMin) * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(extent) and \
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 addNewFeature(self, layer, geometry):
fields = layer.pendingFields()
feature = QgsFeature()
feature.setGeometry( geometry )
feature.initAttributes(fields.count())
feature.setFields(fields)
for indx in xrange(fields.count()):
feature[indx] = layer.dataProvider().defaultValue(indx)
self.openForm(layer, feature)
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.VECTOR), context)
pointCount = int(self.getParameterValue(self.POINT_NUMBER))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
bbox = layer.extent()
idxLayer = QgsProcessingUtils.createSpatialIndex(layer, context)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QgsWkbTypes.Point, layer.crs(), context)
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
ids = idxLayer.intersects(geom.buffer(5, 5).boundingBox())
if len(ids) > 0 and \
vector.checkMinDistance(pnt, index, minDistance, points):
request = QgsFeatureRequest().setFilterFids(ids).setSubsetOfAttributes([])
for f in layer.getFeatures(request):
tmpGeom = f.geometry()
if geom.within(tmpGeom):
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
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
QgsMessageLog.logMessage(self.tr('Can not generate requested number of random points. '
'Maximum number of attempts exceeded.'), self.tr('Processing'), QgsMessageLog.INFO)
del writer
def insertFrameIntoQgsLayer(self, layer, poly, map_index):
"""Inserts the poly into layer
"""
provider = layer.dataProvider()
#Creating the feature
feature = QgsFeature()
feature.initAttributes(1)
feature.setAttribute(0, map_index)
feature.setGeometry(poly)
# Adding the feature into the file
provider.addFeatures([feature])
def addNewFeature(self, layer, geometry):
fields = layer.pendingFields()
if not layer.isEditable():
layer.startEditing()
feature = QgsFeature()
feature.setGeometry( geometry )
feature.initAttributes(fields.count())
feature.setFields(fields)
for indx in xrange(fields.count()):
feature[indx] = layer.dataProvider().defaultValue(indx)
self.dialogprovider.openDialog(feature=feature, layer=layer)
def test_DeleteAttributeByName(self):
fields = QgsFields()
field1 = QgsField("my_field")
fields.append(field1)
field2 = QgsField("my_field2")
fields.append(field2)
feat = QgsFeature(fields)
feat.initAttributes(2)
feat[0] = "text1"
feat[1] = "text2"
with self.assertRaises(KeyError):
feat.deleteAttribute("not present")
self.assertTrue(feat.deleteAttribute("my_field"))
self.assertEqual(feat.attributes(), ["text2"])
def canvasPressEvent(self, mouseEvent):
self.rubber.reset()
match = self.snap_to_intersection(mouseEvent.pos())
if match.type() != QgsPointLocator.Vertex or match.layer() is not None:
return
layer = self.checkLayer()
if layer is None:
return
f = QgsFeature()
initFields = layer.dataProvider().fields()
f.setFields(initFields)
f.initAttributes(initFields.size())
f.setGeometry(QgsGeometry().fromPoint(match.point()))
layer.editBuffer().addFeature(f)
layer.triggerRepaint()
def checkCancel(self, job_type):
"""test canceling a render job"""
layer = QgsVectorLayer("Point?field=fldtxt:string",
"layer1", "memory")
# add a ton of random points
for i in range(2000):
x = uniform(5, 25)
y = uniform(25, 45)
g = QgsGeometry.fromPointXY(QgsPointXY(x, y))
f = QgsFeature()
f.setGeometry(g)
f.initAttributes(1)
layer.dataProvider().addFeatures([f])
settings = QgsMapSettings()
settings.setExtent(QgsRectangle(5, 25, 25, 45))
settings.setOutputSize(QSize(600, 400))
settings.setLayers([layer])
# first try non-blocking cancelWithoutBlocking() call
job = job_type(settings)
finished_spy = QSignalSpy(job.finished)
job.start()
# insta cancel!
job.cancelWithoutBlocking()
# should still be active immediately after
self.assertTrue(job.isActive())
while job.isActive():
app.processEvents()
self.assertEqual(len(finished_spy), 1)
# try blocking cancel() call
job = job_type(settings)
finished_spy = QSignalSpy(job.finished)
job.start()
# insta cancel!
job.cancel()
# should not be active anymore
self.assertFalse(job.isActive())
self.assertEqual(len(finished_spy), 1)
def regularize(self, bound, outPath, offset, value, gridType, inset, crs):
area = bound.width() * bound.height()
if offset:
seed()
if gridType:
pointSpacing = value
else:
# Calculate grid spacing
pointSpacing = sqrt(area / value)
outFeat = QgsFeature()
outFeat.initAttributes(1)
fields = QgsFields()
fields.append( QgsField("ID", QVariant.Int) )
outFeat.setFields( fields )
check = QFile(self.shapefileName)
if check.exists():
if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName):
return
writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPoint, crs)
idVar = 0
count = 10.00
add = 90.00 / (area / pointSpacing)
y = bound.yMaximum() - inset
while y >= bound.yMinimum():
x = bound.xMinimum() + inset
while x <= bound.xMaximum():
if offset:
pGeom = QgsGeometry().fromPoint( QgsPoint(
uniform(x - (pointSpacing / 2.0), x + (pointSpacing / 2.0)),
uniform(y - (pointSpacing / 2.0), y + (pointSpacing / 2.0))
))
else:
pGeom = QgsGeometry().fromPoint(QgsPoint(x, y))
if pGeom.intersects(bound):
outFeat.setGeometry(pGeom)
outFeat.setAttribute(0, idVar)
writer.addFeature(outFeat)
idVar = idVar + 1
x = x + pointSpacing
count = count + add
self.progressBar.setValue(count)
y = y - pointSpacing
del writer
def restoreFeature(self):
if not self.featureLayer.isEditable():
return False
currentFeature = self.getLayerFeature()
editBuffer = self.featureLayer.editBuffer()
if currentFeature is not None:
fid = currentFeature.id()
for idx, field in enumerate(self.fields):
value = self.getFieldValue(self.logData, field.name())
editBuffer.changeAttributeValue(fid, idx, value)
if self.featureLayer.hasGeometryType():
editBuffer.changeGeometry(fid, self.geometry())
else:
newFeature = QgsFeature()
newFeature.setFields(self.fields)
newFeature.initAttributes(self.fields.size())
for field in self.fields:
value = self.getFieldValue(self.logData, field.name())
newFeature[field.name()] = value
if self.featureLayer.hasGeometryType():
newFeature.setGeometry(self.geometry())
editBuffer.addFeature(newFeature)
def processAlgorithm(self, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.VECTOR), context)
groupField = self.getParameterValue(self.GROUP_FIELD)
orderField = self.getParameterValue(self.ORDER_FIELD)
dateFormat = str(self.getParameterValue(self.DATE_FORMAT))
#gap = int(self.getParameterValue(self.GAP_PERIOD))
dirName = self.getOutputValue(self.OUTPUT_TEXT)
fields = QgsFields()
fields.append(QgsField('group', QVariant.String, '', 254, 0))
fields.append(QgsField('begin', QVariant.String, '', 254, 0))
fields.append(QgsField('end', QVariant.String, '', 254, 0))
writer = self.getOutputFromName(self.OUTPUT_LINES).getVectorWriter(
fields, QgsWkbTypes.LineString, layer.crs(), context)
points = dict()
features = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / QgsProcessingUtils.featureCount(layer, context)
for current, f in enumerate(features):
point = f.geometry().asPoint()
group = f[groupField]
order = f[orderField]
if dateFormat != '':
order = datetime.strptime(str(order), dateFormat)
if group in points:
points[group].append((order, point))
else:
points[group] = [(order, point)]
feedback.setProgress(int(current * total))
feedback.setProgress(0)
da = QgsDistanceArea()
current = 0
total = 100.0 / len(points)
for group, vertices in list(points.items()):
vertices.sort()
f = QgsFeature()
f.initAttributes(len(fields))
f.setFields(fields)
f['group'] = group
f['begin'] = vertices[0][0]
f['end'] = vertices[-1][0]
fileName = os.path.join(dirName, '%s.txt' % group)
with open(fileName, 'w') as fl:
fl.write('angle=Azimuth\n')
fl.write('heading=Coordinate_System\n')
fl.write('dist_units=Default\n')
line = []
i = 0
for node in vertices:
line.append(node[1])
if i == 0:
fl.write('startAt=%f;%f;90\n' %
(node[1].x(), node[1].y()))
fl.write('survey=Polygonal\n')
fl.write('[data]\n')
else:
angle = line[i - 1].azimuth(line[i])
distance = da.measureLine(line[i - 1], line[i])
fl.write('%f;%f;90\n' % (angle, distance))
i += 1
f.setGeometry(QgsGeometry.fromPolyline(line))
writer.addFeature(f)
current += 1
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, feedback):
extent = str(self.getParameterValue(self.EXTENT)).split(',')
spacing = float(self.getParameterValue(self.SPACING))
inset = float(self.getParameterValue(self.INSET))
randomize = self.getParameterValue(self.RANDOMIZE)
isSpacing = self.getParameterValue(self.IS_SPACING)
crsId = self.getParameterValue(self.CRS)
crs = QgsCoordinateReferenceSystem()
crs.createFromUserInput(crsId)
extent = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, crs)
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(
extent_geom.geometry())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if randomize:
geom = QgsGeometry().fromPoint(
QgsPoint(
uniform(x - (pSpacing / 2.0),
x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0),
y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPoint(QgsPoint(x, y))
if extent_engine.intersects(geom.geometry()):
f.setAttribute('id', count)
f.setGeometry(geom)
writer.addFeature(f)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
del writer
def test_SetAttributes(self):
feat = QgsFeature()
feat.initAttributes(1)
feat.setAttributes([0])
feat.setAttributes([NULL])
assert [NULL] == feat.attributes()
def processAlgorithm(self, progress):
""" Based on code by Matthew Perry
https://gist.github.com/perrygeo/5667173
"""
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_VECTOR))
rasterPath = unicode(self.getParameterValue(self.INPUT_RASTER))
bandNumber = self.getParameterValue(self.RASTER_BAND)
columnPrefix = self.getParameterValue(self.COLUMN_PREFIX)
useGlobalExtent = self.getParameterValue(self.GLOBAL_EXTENT)
rasterDS = gdal.Open(rasterPath, gdal.GA_ReadOnly)
geoTransform = rasterDS.GetGeoTransform()
rasterBand = rasterDS.GetRasterBand(bandNumber)
noData = rasterBand.GetNoDataValue()
cellXSize = abs(geoTransform[1])
cellYSize = abs(geoTransform[5])
rasterXSize = rasterDS.RasterXSize
rasterYSize = rasterDS.RasterYSize
rasterBBox = QgsRectangle(geoTransform[0], geoTransform[3] - cellYSize
* rasterYSize, geoTransform[0] + cellXSize
* rasterXSize, geoTransform[3])
rasterGeom = QgsGeometry.fromRect(rasterBBox)
crs = osr.SpatialReference()
crs.ImportFromProj4(str(layer.crs().toProj4()))
if useGlobalExtent:
xMin = rasterBBox.xMinimum()
xMax = rasterBBox.xMaximum()
yMin = rasterBBox.yMinimum()
yMax = rasterBBox.yMaximum()
(startColumn, startRow) = mapToPixel(xMin, yMax, geoTransform)
(endColumn, endRow) = mapToPixel(xMax, yMin, geoTransform)
width = endColumn - startColumn
height = endRow - startRow
srcOffset = (startColumn, startRow, width, height)
srcArray = rasterBand.ReadAsArray(*srcOffset)
newGeoTransform = (
geoTransform[0] + srcOffset[0] * geoTransform[1],
geoTransform[1],
0.0,
geoTransform[3] + srcOffset[1] * geoTransform[5],
0.0,
geoTransform[5],
)
memVectorDriver = ogr.GetDriverByName('Memory')
memRasterDriver = gdal.GetDriverByName('MEM')
fields = layer.pendingFields()
(idxMin, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'min', 21, 6)
(idxMax, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'max', 21, 6)
(idxSum, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'sum', 21, 6)
(idxCount, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'count', 21, 6)
(idxMean, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'mean', 21, 6)
(idxStd, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'std', 21, 6)
(idxUnique, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'unique', 21, 6)
(idxRange, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'range', 21, 6)
(idxVar, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'var', 21, 6)
(idxMedian, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'median', 21, 6)
if hasSciPy:
(idxMode, fields) = vector.findOrCreateField(layer, fields,
columnPrefix + 'mode', 21, 6)
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
fields.toList(), layer.dataProvider().geometryType(), layer.crs())
outFeat = QgsFeature()
outFeat.initAttributes(len(fields))
outFeat.setFields(fields)
current = 0
features = vector.features(layer)
total = 100.0 / len(features)
for f in features:
geom = f.geometry()
intersectedGeom = rasterGeom.intersection(geom)
ogrGeom = ogr.CreateGeometryFromWkt(intersectedGeom.exportToWkt())
if not useGlobalExtent:
bbox = intersectedGeom.boundingBox()
xMin = bbox.xMinimum()
xMax = bbox.xMaximum()
yMin = bbox.yMinimum()
yMax = bbox.yMaximum()
(startColumn, startRow) = mapToPixel(xMin, yMax, geoTransform)
(endColumn, endRow) = mapToPixel(xMax, yMin, geoTransform)
width = endColumn - startColumn
height = endRow - startRow
if width == 0 or height == 0:
continue
srcOffset = (startColumn, startRow, width, height)
srcArray = rasterBand.ReadAsArray(*srcOffset)
newGeoTransform = (
geoTransform[0] + srcOffset[0] * geoTransform[1],
geoTransform[1],
0.0,
geoTransform[3] + srcOffset[1] * geoTransform[5],
0.0,
geoTransform[5],
)
# Create a temporary vector layer in memory
memVDS = memVectorDriver.CreateDataSource('out')
memLayer = memVDS.CreateLayer('poly', crs, ogr.wkbPolygon)
ft = ogr.Feature(memLayer.GetLayerDefn())
ft.SetGeometry(ogrGeom)
memLayer.CreateFeature(ft)
ft.Destroy()
# Rasterize it
rasterizedDS = memRasterDriver.Create('', srcOffset[2],
srcOffset[3], 1, gdal.GDT_Byte)
rasterizedDS.SetGeoTransform(newGeoTransform)
gdal.RasterizeLayer(rasterizedDS, [1], memLayer, burn_values=[1])
rasterizedArray = rasterizedDS.ReadAsArray()
srcArray = numpy.nan_to_num(srcArray)
masked = numpy.ma.MaskedArray(srcArray,
mask=numpy.logical_or(srcArray == noData,
numpy.logical_not(rasterizedArray)))
outFeat.setGeometry(geom)
attrs = f.attributes()
attrs.insert(idxMin, float(masked.min()))
attrs.insert(idxMax, float(masked.max()))
attrs.insert(idxSum, float(masked.sum()))
attrs.insert(idxCount, int(masked.count()))
attrs.insert(idxMean, float(masked.mean()))
attrs.insert(idxStd, float(masked.std()))
attrs.insert(idxUnique, numpy.unique(masked.compressed()).size)
attrs.insert(idxRange, float(masked.max()) - float(masked.min()))
attrs.insert(idxVar, float(masked.var()))
attrs.insert(idxMedian, float(numpy.ma.median(masked)))
if hasSciPy:
attrs.insert(idxMode, float(mode(masked, axis=None)[0][0]))
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
memVDS = None
rasterizedDS = None
current += 1
progress.setPercentage(int(current * total))
rasterDS = None
del writer
def processAlgorithm(self, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(
self.getParameterValue(self.VECTOR), context)
fieldName = self.getParameterValue(self.FIELD)
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
strategy = self.getParameterValue(self.STRATEGY)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, layer.crs(), context)
da = QgsDistanceArea()
features = QgsProcessingUtils.getFeatures(layer, context)
for current, f in enumerate(features):
fGeom = f.geometry()
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(f[fieldName])
else:
pointCount = int(round(f[fieldName] * da.measureArea(fGeom)))
if pointCount == 0:
feedback.pushInfo(
"Skip feature {} as number of points for it is 0.")
continue
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(fGeom) and \
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
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
QgsMessageLog.logMessage(
self.tr('Can not generate requested number of random '
'points. Maximum number of attempts exceeded.'),
self.tr('Processing'), QgsMessageLog.INFO)
feedback.setProgress(0)
del writer
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
if output.value == '':
ext = output.getDefaultFileExtension(self)
output.value = system.getTempFilenameInTempFolder(
output.name + '.' + ext)
provider = layer.dataProvider()
fields = layer.pendingFields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, provider.geometryType(),
layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
if not exp.prepare(layer.pendingFields()):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
current = 0
features = vector.features(layer)
total = 100.0 / len(features)
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp.setCurrentRowNumber(rownum)
value = exp.evaluate(f)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
progress.setPercentage(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occured while evaluating the calculation '
'string:\n%s' % error))
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER,
context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE,
context)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point,
source.sourceCrs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
featureCount = source.featureCount()
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs(), context.transformContext())
da.setEllipsoid(context.project().ellipsoid())
request = QgsFeatureRequest()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
# pick random feature
fid = random.randint(0, featureCount - 1)
f = next(
source.getFeatures(
request.setFilterFid(fid).setSubsetOfAttributes([])))
fGeom = 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
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
if vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(
self.tr(
'Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, progress):
extent = self.getParameterValue(self.EXTENT).split(',')
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS))
bbox = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
width = bbox.width()
height = bbox.height()
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: %s/%s' % (hSpacing, vSpacing)))
if width < hSpacing:
raise GeoAlgorithmExecutionException(
self.tr(
'Horizontal spacing is too small for the covered area'))
if height < vSpacing:
raise GeoAlgorithmExecutionException(
self.tr('Vertical spacing is too small for the covered area'))
fields = [
QgsField('left', QVariant.Double, '', 24, 16),
QgsField('top', QVariant.Double, '', 24, 16),
QgsField('right', QVariant.Double, '', 24, 16),
QgsField('bottom', QVariant.Double, '', 24, 16),
QgsField('id', QVariant.Int, '', 10, 0),
QgsField('coord', QVariant.Double, '', 24, 15)
]
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.LineString, crs)
feat = QgsFeature()
feat.initAttributes(len(fields))
count = 0
id = 1
# latitude lines
count_max = height / vSpacing
count_update = count_max * 0.10
y = bbox.yMaximum()
while y >= bbox.yMinimum():
pt1 = QgsPointV2(bbox.xMinimum(), y)
pt2 = QgsPointV2(bbox.xMaximum(), y)
line = QgsLineString()
line.setPoints([pt1, pt2])
feat.setGeometry(QgsGeometry(line))
feat.setAttributes([bbox.xMinimum(), y, bbox.xMaximum(), y, id, y])
writer.addFeature(feat)
y = y - vSpacing
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
progress.setPercentage(int(count / count_max * 50))
progress.setPercentage(50)
# longitude lines
# counters for progressbar - update every 5%
count = 0
count_max = width / hSpacing
count_update = count_max * 0.10
x = bbox.xMinimum()
while x <= bbox.xMaximum():
pt1 = QgsPointV2(x, bbox.yMaximum())
pt2 = QgsPointV2(x, bbox.yMinimum())
line = QgsLineString()
line.setPoints([pt1, pt2])
feat.setGeometry(QgsGeometry(line))
feat.setAttributes([x, bbox.yMaximum(), x, bbox.yMinimum(), id, x])
writer.addFeature(feat)
x = x + hSpacing
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
progress.setPercentage(50 + int(count / count_max * 50))
del writer
def processAlgorithm(self, parameters, context, feedback):
spacing = self.parameterAsDouble(parameters, self.SPACING, context)
inset = self.parameterAsDouble(parameters, self.INSET, context)
randomize = self.parameterAsBool(parameters, self.RANDOMIZE, context)
isSpacing = self.parameterAsBool(parameters, self.IS_SPACING, context)
crs = self.parameterAsCrs(parameters, self.CRS, context)
extent = self.parameterAsExtent(parameters, self.EXTENT, context, crs)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point, crs)
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
if randomize:
seed()
area = extent.width() * extent.height()
if isSpacing:
pSpacing = spacing
else:
pSpacing = sqrt(area / spacing)
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
count = 0
total = 100.0 / (area / pSpacing)
y = extent.yMaximum() - inset
extent_geom = QgsGeometry.fromRect(extent)
extent_engine = QgsGeometry.createGeometryEngine(
extent_geom.constGet())
extent_engine.prepareGeometry()
while y >= extent.yMinimum():
x = extent.xMinimum() + inset
while x <= extent.xMaximum():
if feedback.isCanceled():
break
if randomize:
geom = QgsGeometry().fromPointXY(
QgsPointXY(
uniform(x - (pSpacing / 2.0),
x + (pSpacing / 2.0)),
uniform(y - (pSpacing / 2.0),
y + (pSpacing / 2.0))))
else:
geom = QgsGeometry().fromPointXY(QgsPointXY(x, y))
if extent_engine.intersects(geom.constGet()):
f.setAttribute('id', count)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
x += pSpacing
count += 1
feedback.setProgress(int(count * total))
y = y - pSpacing
return {self.OUTPUT: dest_id}
def processAlgorithm(self, parameters, context, feedback):
layer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.INPUT_LAYER), context)
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs(), context)
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs())
da.setEllipsoid(context.project().ellipsoid())
exp.setGeomCalculator(da)
exp.setDistanceUnits(context.project().distanceUnits())
exp.setAreaUnits(context.project().areaUnits())
exp_context = QgsExpressionContext(QgsExpressionContextUtils.globalProjectLayerScopes(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: {0}').format(exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = QgsProcessingUtils.getFeatures(layer, context)
total = 100.0 / layer.featureCount() if layer.featureCount() else 0
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n{0}').format(error))
def processAlgorithm(self, parameters, context, feedback):
hSpacing = self.parameterAsDouble(parameters, self.HSPACING, context)
vSpacing = self.parameterAsDouble(parameters, self.VSPACING, context)
hOverlay = self.parameterAsDouble(parameters, self.HOVERLAY, context)
vOverlay = self.parameterAsDouble(parameters, self.VOVERLAY, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
crs = self.parameterAsCrs(parameters, self.CRS, context)
width = bbox.width()
height = bbox.height()
if hSpacing <= 0 or vSpacing <= 0:
raise QgsProcessingException(
self.tr('Invalid grid spacing: {0}/{1}').format(
hSpacing, vSpacing))
if hSpacing <= hOverlay or vSpacing <= vOverlay:
raise QgsProcessingException(
self.tr('Invalid overlay: {0}/{1}').format(hOverlay, vOverlay))
if width < hSpacing:
raise QgsProcessingException(
self.tr(
'Horizontal spacing is too small for the covered area'))
if height < vSpacing:
raise QgsProcessingException(
self.tr('Vertical spacing is too small for the covered area'))
fields = QgsFields()
fields.append(QgsField('left', QVariant.Double, '', 24, 16))
fields.append(QgsField('top', QVariant.Double, '', 24, 16))
fields.append(QgsField('right', QVariant.Double, '', 24, 16))
fields.append(QgsField('bottom', QVariant.Double, '', 24, 16))
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
fields.append(QgsField('coord', QVariant.Double, '', 24, 15))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.LineString, crs)
if hOverlay > 0:
hSpace = [hSpacing - hOverlay, hOverlay]
else:
hSpace = [hSpacing, hSpacing]
if vOverlay > 0:
vSpace = [vSpacing - vOverlay, vOverlay]
else:
vSpace = [vSpacing, vSpacing]
feat = QgsFeature()
feat.initAttributes(len(fields))
count = 0
id = 1
# latitude lines
count_max = height / vSpacing
count_update = count_max * 0.10
y = bbox.yMaximum()
while y >= bbox.yMinimum():
if feedback.isCanceled():
break
pt1 = QgsPoint(bbox.xMinimum(), y)
pt2 = QgsPoint(bbox.xMaximum(), y)
line = QgsLineString()
line.setPoints([pt1, pt2])
feat.setGeometry(QgsGeometry(line))
feat.setAttributes([bbox.xMinimum(), y, bbox.xMaximum(), y, id, y])
sink.addFeature(feat, QgsFeatureSink.FastInsert)
y = y - vSpace[count % 2]
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(int(count / count_max * 50))
feedback.setProgress(50)
# longitude lines
# counters for progressbar - update every 5%
count = 0
count_max = width / hSpacing
count_update = count_max * 0.10
x = bbox.xMinimum()
while x <= bbox.xMaximum():
if feedback.isCanceled():
break
pt1 = QgsPoint(x, bbox.yMaximum())
pt2 = QgsPoint(x, bbox.yMinimum())
line = QgsLineString()
line.setPoints([pt1, pt2])
feat.setGeometry(QgsGeometry(line))
feat.setAttributes([x, bbox.yMaximum(), x, bbox.yMinimum(), id, x])
sink.addFeature(feat, QgsFeatureSink.FastInsert)
x = x + hSpace[count % 2]
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(50 + int(count / count_max * 50))
return {self.OUTPUT: dest_id}
def processAlgorithm(self, feedback):
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, QgsWkbTypes.Point, layer.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 = next(
layer.getFeatures(
request.setFilterFid(fid).setSubsetOfAttributes([])))
fGeom = 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
feedback.setProgress(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))
strategy = self.parameterAsEnum(parameters, self.STRATEGY, context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE,
context)
expression = QgsExpression(
self.parameterAsString(parameters, self.EXPRESSION, context))
if expression.hasParserError():
raise QgsProcessingException(expression.parserErrorString())
expressionContext = self.createExpressionContext(
parameters, context, source)
expression.prepare(expressionContext)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point,
source.sourceCrs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
da = QgsDistanceArea()
da.setSourceCrs(source.sourceCrs(), context.transformContext())
da.setEllipsoid(context.project().ellipsoid())
total = 100.0 / source.featureCount() if source.featureCount() else 0
current_progress = 0
for current, f in enumerate(source.getFeatures()):
if feedback.isCanceled():
break
if not f.hasGeometry():
continue
current_progress = total * current
feedback.setProgress(current_progress)
expressionContext.setFeature(f)
value = expression.evaluate(expressionContext)
if expression.hasEvalError():
feedback.pushInfo(
self.tr('Evaluation error for feature ID {}: {}').format(
f.id(), expression.evalErrorString()))
continue
fGeom = f.geometry()
engine = QgsGeometry.createGeometryEngine(fGeom.constGet())
engine.prepareGeometry()
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(value)
else:
pointCount = int(round(value * da.measureArea(fGeom)))
if pointCount == 0:
feedback.pushInfo(
"Skip feature {} as number of points for it is 0.".format(
f.id()))
continue
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
feature_total = total / pointCount if pointCount else 1
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
if engine.contains(geom.constGet()) and \
vector.checkMinDistance(p, index, minDistance, points):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.addFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(current_progress +
int(nPoints * feature_total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(
self.tr('Could not generate requested number of random '
'points. Maximum number of attempts exceeded.'))
feedback.setProgress(100)
return {self.OUTPUT: dest_id}
def extract(self, outPath, tableName):
# main process
# open target point layer
targetLayer = self.targetItems[str(self.TargetLayer.currentText())][0]
targetprovider = targetLayer.dataProvider()
allAttrs = targetprovider.attributeIndexes()
sRs = targetLayer.crs()
# create output layer: first create list of selected fields
fieldList = QgsFields()
for i in range(len(self.fields)):
if self.fields[i][0] == "point":
# copying fields from source layer
field = targetprovider.fields()[targetprovider.fieldNameIndex(self.targetItems[self.fields[i][1]][self.fields[i][2]][0])]
field.setName(self.targetItems[self.fields[i][1]][self.fields[i][2]][1])
elif self.fields[i][0] == "polygon":
# copying fields from polygon layers
polyLayer = self.polygonItems[self.fields[i][1]][0]
polyProvider = polyLayer.dataProvider()
field = polyProvider.fields()[polyProvider.fieldNameIndex(self.polygonItems[self.fields[i][1]][self.fields[i][2]][0])]
field.setName(self.polygonItems[self.fields[i][1]][self.fields[i][2]][1])
else:
# creating fields for raster layers
field = QgsField(self.rasterItems[self.fields[i][1]][self.fields[i][2]][1], QVariant.Double, "real", 20, 5, "")
fieldList.append(field)
# create temporary memory layer
memLayer = QgsVectorLayer("Point?crs=epsg:%d" % sRs.postgisSrid(), 'temp layer', 'memory')
memLayer.startEditing()
for field in fieldList:
memLayer.addAttribute(field)
memLayer.commitChanges()
self.repaint()
# process point after point
pointFeat = QgsFeature()
np = 0
snp = targetprovider.featureCount()
for pointFeat in targetprovider.getFeatures():
np += 1
# convert multipoint[0] to point
pointGeom = pointFeat.geometry()
if pointGeom.wkbType() == QgsWkbTypes.MultiPoint:
pointPoint = pointGeom.asMultiPoint()[0]
else:
pointPoint = pointGeom.asPoint()
outFeat = QgsFeature()
outFeat.setGeometry(pointGeom)
# and next loop inside: field after field
bBox = QgsRectangle(pointPoint.x()-0.001,pointPoint.y()-0.001,pointPoint.x()+0.001,pointPoint.y()+0.001)
# reusable rectangle buffer around the point feature
previousPolyLayer = None # reuse previous feature if it's still the same layer
previousPolyFeat = None # reuse previous feature if it's still the same layer
previousRastLayer = None # reuse previous raster multichannel sample if it's still the same layer
previousRastSample = None # reuse previous raster multichannel sample if it's still the same layer
attrs = []
for i in range(len(self.fields)):
field = self.fields[i]
if field[0] == "point":
attr = pointFeat.attributes()[targetprovider.fieldNameIndex(self.targetItems[field[1]][field[2]][0])]
attrs += [attr]
elif field[0] == "polygon":
polyLayer = self.polygonItems[field[1]][0]
polyProvider = polyLayer.dataProvider()
if polyLayer == previousPolyLayer:
polyFeat = previousPolyFeat
else:
polyFeat = None
pointGeom = QgsGeometry().fromPointXY(pointPoint)
for iFeat in polyProvider.getFeatures(QgsFeatureRequest().setFilterRect(bBox)):
if pointGeom.intersects(iFeat.geometry()):
polyFeat = iFeat
if polyFeat:
attr = polyFeat.attributes()[polyProvider.fieldNameIndex(self.polygonItems[field[1]][field[2]][0])]
else:
attr = None
attrs += [attr]
#only last one if more polygons overlaps
previousPolyLayer = polyLayer
previousPolyFeat = polyFeat
else:
# raster
rastLayer = self.rasterItems[field[1]][0]
if rastLayer == previousRastLayer:
rastSample = previousRastSample
else:
rastSample = rastLayer.dataProvider().identify(pointPoint, QgsRaster.IdentifyFormatValue).results()
try:
bandNo = field[2]
attr = float(rastSample[bandNo])
except: # point is out of raster extent
attr = None
attrs += [attr]
previousRastLayer = rastLayer
previousRastSample = rastSample
outFeat.initAttributes(len(attrs))
outFeat.setAttributes(attrs)
memLayer.dataProvider().addFeature(outFeat)
# write memlayer to the output file
so = QgsVectorFileWriter.SaveVectorOptions()
so.fileEncoding = 'UTF-8'
if outPath.upper().endswith('SHP'):
so.driverName = "ESRI Shapefile"
elif outPath.upper().endswith('CSV'):
so.driverName = "CSV"
else:
so.driverName = "GPKG"
if tableName:
so.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer
so.layerName = tableName
result, errMsg = QgsVectorFileWriter.writeAsVectorFormat(memLayer, outPath, so)
if result:
QMessageBox.critical(self, self.tr("Extract tool"), errMsg)
return False
else:
del memLayer
return True
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(
self.INPUT))
method = self.getParameterValue(self.METHOD)
geometryType = layer.geometryType()
fields = layer.fields()
export_z = False
export_m = False
if geometryType == QgsWkbTypes.PolygonGeometry:
areaName = vector.createUniqueFieldName('area', fields)
fields.append(QgsField(areaName, QVariant.Double))
perimeterName = vector.createUniqueFieldName('perimeter', fields)
fields.append(QgsField(perimeterName, QVariant.Double))
elif geometryType == QgsWkbTypes.LineGeometry:
lengthName = vector.createUniqueFieldName('length', fields)
fields.append(QgsField(lengthName, QVariant.Double))
else:
xName = vector.createUniqueFieldName('xcoord', fields)
fields.append(QgsField(xName, QVariant.Double))
yName = vector.createUniqueFieldName('ycoord', fields)
fields.append(QgsField(yName, QVariant.Double))
if QgsWkbTypes.hasZ(layer.wkbType()):
export_z = True
zName = vector.createUniqueFieldName('zcoord', fields)
fields.append(QgsField(zName, QVariant.Double))
if QgsWkbTypes.hasM(layer.wkbType()):
export_m = True
zName = vector.createUniqueFieldName('mvalue', fields)
fields.append(QgsField(zName, QVariant.Double))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields.toList(), layer.wkbType(), layer.crs())
ellips = None
crs = None
coordTransform = None
# Calculate with:
# 0 - layer CRS
# 1 - project CRS
# 2 - ellipsoidal
if method == 2:
ellips = QgsProject.instance().readEntry('Measure', '/Ellipsoid',
'NONE')[0]
crs = layer.crs().srsid()
elif method == 1:
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
layCRS = layer.crs()
coordTransform = QgsCoordinateTransform(layCRS, mapCRS)
outFeat = QgsFeature()
inGeom = QgsGeometry()
outFeat.initAttributes(len(fields))
outFeat.setFields(fields)
features = vector.features(layer)
total = 100.0 / len(features)
for current, f in enumerate(features):
inGeom = f.geometry()
if method == 1:
inGeom.transform(coordTransform)
(attr1, attr2) = vector.simpleMeasure(inGeom, method, ellips, crs)
outFeat.setGeometry(inGeom)
attrs = f.attributes()
attrs.append(attr1)
if attr2 is not None:
attrs.append(attr2)
# add point z/m
if export_z:
attrs.append(inGeom.geometry().z())
if export_m:
attrs.append(inGeom.geometry().m())
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
progress.setPercentage(int(current * total))
del writer
def processAlgorithm(self, feedback):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
exp.setDistanceUnits(QgsProject.instance().distanceUnits())
exp.setAreaUnits(QgsProject.instance().areaUnits())
exp_context = QgsExpressionContext(
QgsExpressionContextUtils.globalProjectLayerScopes(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = vector.features(layer)
total = 100.0 / len(features)
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
feedback.setProgress(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n%s' % error))
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.VECTOR))
value = float(self.getParameterValue(self.VALUE))
minDistance = float(self.getParameterValue(self.MIN_DISTANCE))
strategy = self.getParameterValue(self.STRATEGY)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.Point, layer.crs())
da = QgsDistanceArea()
features = vector.features(layer)
for current, f in enumerate(features):
fGeom = f.geometry()
bbox = fGeom.boundingBox()
if strategy == 0:
pointCount = int(value)
else:
pointCount = int(round(value * da.measureArea(fGeom)))
index = QgsSpatialIndex()
points = dict()
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
pnt = QgsPoint(rx, ry)
geom = QgsGeometry.fromPoint(pnt)
if geom.within(fGeom) and \
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.'))
progress.setPercentage(0)
del writer
def testFieldGroupMultiLayer(self):
# create a layer
states = QgsVectorLayer("Point?crs=epsg:4326&field=country:string(20)&field=state:string(20)", "points", "memory")
attributes = [
['Australia', 'QLD'],
['NZ', 'state1'],
['Australia', 'VIC'],
['NZ', 'state2'],
['PNG', 'state3'],
['Australia', 'NSW']
]
pr = states.dataProvider()
for a in attributes:
f = QgsFeature()
f.initAttributes(2)
f.setAttribute(0, a[0])
f.setAttribute(1, a[1])
self.assertTrue(pr.addFeature(f))
places = QgsVectorLayer("Point?crs=epsg:4326&field=state:string(20)&field=town:string(20)", "points", "memory")
attributes = [
['QLD', 'Brisbane'],
['QLD', 'Emerald'],
['state1', 'town1'],
['VIC', 'Melbourne'],
['state1', 'town2'],
['QLD', 'Beerburrum'],
['VIC', 'Geelong'],
['state3', 'town1']
]
pr = places.dataProvider()
for a in attributes:
f = QgsFeature()
f.initAttributes(2)
f.setAttribute(0, a[0])
f.setAttribute(1, a[1])
self.assertTrue(pr.addFeature(f))
p = QgsProject()
r = QgsReport(p)
# add a child
child1 = QgsReportSectionFieldGroup()
child1_body = QgsLayout(p)
child1.setLayer(states)
child1.setBody(child1_body)
child1.setBodyEnabled(True)
child1.setField('country')
r.appendChild(child1)
self.assertTrue(r.beginRender())
self.assertTrue(r.next())
self.assertEqual(r.layout(), child1_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'QLD'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child1_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'VIC'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child1_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'NSW'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child1_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child1_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state2'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child1_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['PNG', 'state3'])
self.assertFalse(r.next())
# another group
# remove body from child1
child1.setBodyEnabled(False)
child2 = QgsReportSectionFieldGroup()
child2_body = QgsLayout(p)
child2.setLayer(states)
child2.setBody(child2_body)
child2.setBodyEnabled(True)
child2.setField('state')
child1.appendChild(child2)
self.assertTrue(r.beginRender())
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'NSW'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'QLD'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'VIC'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state2'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['PNG', 'state3'])
self.assertFalse(r.next())
# another group
child3 = QgsReportSectionFieldGroup()
child3_body = QgsLayout(p)
child3.setLayer(places)
child3.setBody(child3_body)
child3.setBodyEnabled(True)
child3.setField('town')
child3.setSortAscending(False)
child2.appendChild(child3)
self.assertTrue(r.beginRender())
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'NSW'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'QLD'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Emerald'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Brisbane'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Beerburrum'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'VIC'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Melbourne'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Geelong'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town2'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state2'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['PNG', 'state3'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state3', 'town1'])
self.assertFalse(r.next())
# add headers/footers
child3_header = QgsLayout(p)
child3.setHeader(child3_header)
child3.setHeaderEnabled(True)
child3_footer = QgsLayout(p)
child3.setFooter(child3_footer)
child3.setFooterEnabled(True)
self.assertTrue(r.beginRender())
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'NSW'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'QLD'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_header)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Emerald'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Emerald'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Brisbane'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Beerburrum'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_footer)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['QLD', 'Beerburrum'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['Australia', 'VIC'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_header)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Melbourne'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Melbourne'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Geelong'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_footer)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['VIC', 'Geelong'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_header)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town2'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town2'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_footer)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state1', 'town1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['NZ', 'state2'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child2_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['PNG', 'state3'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_header)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state3', 'town1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_body)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state3', 'town1'])
self.assertTrue(r.next())
self.assertEqual(r.layout(), child3_footer)
self.assertEqual(r.layout().reportContext().feature().attributes(), ['state3', 'town1'])
self.assertFalse(r.next())
def processAlgorithm(self, progress):
vlayerA = dataobjects.getObjectFromUri(
self.getParameterValue(Dissolve.INPUT))
vproviderA = vlayerA.dataProvider()
fields = QgsFields()
fieldname = self.getParameterValue(Dissolve.FIELD)
try:
fieldIdx = vlayerA.fieldNameIndex(fieldname)
field = vlayerA.fields().field(fieldname)
fields.append(field)
useField = True
except:
useField = False
countField = QgsField("count", QVariant.Int, '', 10, 0)
fields.append(countField)
writer = self.getOutputFromName(Dissolve.OUTPUT).getVectorWriter(
fields, vproviderA.geometryType(), vproviderA.crs())
outFeat = QgsFeature()
outFeat.initAttributes(fields.count())
nElement = 0
nFeat = vlayerA.selectedFeatureCount()
if nFeat == 0:
nFeat = vlayerA.featureCount()
if not useField:
first = True
features = vector.features(vlayerA)
for inFeat in features:
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
if first:
tmpOutGeom = QgsGeometry(inFeat.geometry())
first = False
else:
tmpInGeom = QgsGeometry(inFeat.geometry())
try:
tmpOutGeom = QgsGeometry(tmpOutGeom.combine(tmpInGeom))
except:
raise GeoAlgorithmExecutionException(
self.tr('Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat[0] = nElement
writer.addFeature(outFeat)
else:
unique = vector.getUniqueValues(vlayerA, int(fieldIdx))
nFeat = len(unique)
myDict = {}
for item in unique:
myDict[unicode(item).strip()] = []
features = vector.features(vlayerA)
for inFeat in features:
attrs = inFeat.attributes()
tempItem = attrs[fieldIdx]
tmpInGeom = QgsGeometry(inFeat.geometry())
if len(myDict[unicode(tempItem).strip()]) == 0:
myDict[unicode(tempItem).strip()].append(tempItem)
myDict[unicode(tempItem).strip()].append(tmpInGeom)
for key, value in myDict.items():
nElement += 1
progress.setPercentage(int(nElement * 100 / nFeat))
for i in range(len(value)):
if i == 0:
tempItem = value[i]
continue
else:
tmpInGeom = value[i]
if i == 1:
tmpOutGeom = tmpInGeom
else:
try:
tmpOutGeom = QgsGeometry(
tmpOutGeom.combine(tmpInGeom))
except:
raise GeoAlgorithmExecutionException(
self.tr(
'Geometry exception while dissolving'))
outFeat.setGeometry(tmpOutGeom)
outFeat[0] = tempItem
outFeat[1] = i
writer.addFeature(outFeat)
del writer
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT))
method = self.getParameterValue(self.METHOD)
geometryType = layer.geometryType()
fields = layer.pendingFields()
if geometryType == QGis.Polygon:
areaName = vector.createUniqueFieldName('area', fields)
fields.append(QgsField(areaName, QVariant.Double))
perimeterName = vector.createUniqueFieldName('perimeter', fields)
fields.append(QgsField(perimeterName, QVariant.Double))
elif geometryType == QGis.Line:
lengthName = vector.createUniqueFieldName('length', fields)
fields.append(QgsField(lengthName, QVariant.Double))
else:
xName = vector.createUniqueFieldName('xcoord', fields)
fields.append(QgsField(xName, QVariant.Double))
yName = vector.createUniqueFieldName('ycoord', fields)
fields.append(QgsField(yName, QVariant.Double))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields.toList(), layer.dataProvider().geometryType(), layer.crs())
ellips = None
crs = None
coordTransform = None
# Calculate with:
# 0 - layer CRS
# 1 - project CRS
# 2 - ellipsoidal
if method == 2:
ellips = QgsProject.instance().readEntry('Measure', '/Ellipsoid',
'NONE')[0]
crs = layer.crs().srsid()
elif method == 1:
mapCRS = iface.mapCanvas().mapRenderer().destinationCrs()
layCRS = layer.crs()
coordTransform = QgsCoordinateTransform(layCRS, mapCRS)
outFeat = QgsFeature()
inGeom = QgsGeometry()
outFeat.initAttributes(len(fields))
outFeat.setFields(fields)
current = 0
features = vector.features(layer)
total = 100.0 / float(len(features))
for f in features:
inGeom = f.geometry()
if method == 1:
inGeom.transform(coordTransform)
(attr1, attr2) = vector.simpleMeasure(inGeom, method, ellips, crs)
outFeat.setGeometry(inGeom)
attrs = f.attributes()
attrs.append(attr1)
if attr2 is not None:
attrs.append(attr2)
outFeat.setAttributes(attrs)
writer.addFeature(outFeat)
current += 1
progress.setPercentage(int(current * total))
del writer
def compute(self, bound, xOffset, yOffset, polygon):
crs = None
layer = ftools_utils.getMapLayerByName(
unicode(self.inShape.currentText()))
if self.angle.value() != 0.0:
bound = self.initRotation(bound)
if layer is None:
crs = self.iface.mapCanvas().mapRenderer().destinationCrs()
else:
crs = layer.crs()
if not crs.isValid():
crs = None
fields = QgsFields()
fields.append(QgsField("ID", QVariant.Int))
fieldCount = 1
if polygon:
fields.append(QgsField("X_MIN", QVariant.Double))
fields.append(QgsField("X_MAX", QVariant.Double))
fields.append(QgsField("Y_MIN", QVariant.Double))
fields.append(QgsField("Y_MAX", QVariant.Double))
fieldCount = 5
check = QFile(self.shapefileName)
if check.exists():
if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName):
return
writer = QgsVectorFileWriter(self.shapefileName, self.encoding,
fields, QGis.WKBPolygon, crs)
else:
fields.append(QgsField("COORD", QVariant.Double))
fieldCount = 2
check = QFile(self.shapefileName)
if check.exists():
if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName):
return
writer = QgsVectorFileWriter(self.shapefileName, self.encoding,
fields, QGis.WKBLineString, crs)
outFeat = QgsFeature()
outFeat.initAttributes(fieldCount)
outFeat.setFields(fields)
outGeom = QgsGeometry()
idVar = 0
self.progressBar.setValue(0)
if not polygon:
# counters for progressbar - update every 5%
count = 0
count_max = (bound.yMaximum() - bound.yMinimum()) / yOffset
count_update = count_max * 0.10
y = bound.yMaximum()
while y >= bound.yMinimum():
pt1 = QgsPoint(bound.xMinimum(), y)
pt2 = QgsPoint(bound.xMaximum(), y)
if self.angle.value() != 0.0:
self.rotatePoint(pt1)
self.rotatePoint(pt2)
line = [pt1, pt2]
outFeat.setGeometry(outGeom.fromPolyline(line))
outFeat.setAttribute(0, idVar)
outFeat.setAttribute(1, y)
writer.addFeature(outFeat)
y = y - yOffset
idVar = idVar + 1
count += 1
if int(math.fmod(count, count_update)) == 0:
prog = int(count / count_max * 50)
self.progressBar.setValue(prog)
self.progressBar.setValue(50)
# counters for progressbar - update every 5%
count = 0
count_max = (bound.xMaximum() - bound.xMinimum()) / xOffset
count_update = count_max * 0.10
x = bound.xMinimum()
while x <= bound.xMaximum():
pt1 = QgsPoint(x, bound.yMaximum())
pt2 = QgsPoint(x, bound.yMinimum())
if self.angle.value() != 0.0:
self.rotatePoint(pt1)
self.rotatePoint(pt2)
line = [pt1, pt2]
outFeat.setGeometry(outGeom.fromPolyline(line))
outFeat.setAttribute(0, idVar)
outFeat.setAttribute(1, x)
writer.addFeature(outFeat)
x = x + xOffset
idVar = idVar + 1
count += 1
if int(math.fmod(count, count_update)) == 0:
prog = 50 + int(count / count_max * 50)
self.progressBar.setValue(prog)
else:
# counters for progressbar - update every 5%
count = 0
count_max = (bound.yMaximum() - bound.yMinimum()) / yOffset
count_update = count_max * 0.05
y = bound.yMaximum()
while y >= bound.yMinimum():
x = bound.xMinimum()
while x <= bound.xMaximum():
pt1 = QgsPoint(x, y)
pt2 = QgsPoint(x + xOffset, y)
pt3 = QgsPoint(x + xOffset, y - yOffset)
pt4 = QgsPoint(x, y - yOffset)
pt5 = QgsPoint(x, y)
if self.angle.value() != 0.0:
self.rotatePoint(pt1)
self.rotatePoint(pt2)
self.rotatePoint(pt3)
self.rotatePoint(pt4)
self.rotatePoint(pt5)
polygon = [[pt1, pt2, pt3, pt4, pt5]]
outFeat.setGeometry(outGeom.fromPolygon(polygon))
outFeat.setAttribute(0, idVar)
outFeat.setAttribute(1, x)
outFeat.setAttribute(2, x + xOffset)
outFeat.setAttribute(3, y - yOffset)
outFeat.setAttribute(4, y)
writer.addFeature(outFeat)
idVar = idVar + 1
x = x + xOffset
y = y - yOffset
count += 1
if int(math.fmod(count, count_update)) == 0:
prog = int(count / count_max * 100)
self.progressBar.setValue(100)
del writer
def run(self):
##################################
###### PEGA A LAYER ATIVA ########
##################################
layer = self.iface.activeLayer()
if not layer:
self.iface.messageBar().pushMessage("Erro",
u"Esperando uma Active Layer!",
level=QgsMessageBar.CRITICAL,
duration=4)
return
if layer.featureCount() == 0:
self.iface.messageBar().pushMessage(
"Erro",
u"a camada não possui feições!",
level=QgsMessageBar.CRITICAL,
duration=4)
return
parametros = layer.source().split(
" "
) # recebe todos os parametros em uma lista ( senha, porta, password etc..)
####################################
###### INICIANDO CONEXÃO DB ########
####################################
# Outra opção para isso, seria usar ex: self.dbname.. self.host.. etc.. direto dentro do laço for.
dbname = ""
host = ""
port = 0
user = ""
password = ""
for i in parametros:
part = i.split("=")
# Recebe os parametros guardados na própria Layer
if "dbname" in part[0]:
dbname = part[1].replace("'", "")
elif "host" in part[0]:
host = part[1].replace("'", "")
elif "port" in part[0]:
port = int(part[1].replace("'", ""))
elif "user" in part[0]:
user = part[1].replace("'", "")
elif "password" in part[0]:
password = part[1].split("|")[0].replace("'", "")
print dbname, host, port, user, password
# Testa se os parametros receberam os valores pretendidos, caso não, apresenta a mensagem informando..
if len(dbname) == 0 or len(host) == 0 or port == 0 or len(
user) == 0 or len(password) == 0:
self.iface.messageBar().pushMessage(
"Erro",
u'Um dos parametros não foram devidamente recebidos!',
level=QgsMessageBar.CRITICAL,
duration=4)
return
####################################
#### SETA VALORES DE CONEXÃO DB ####
####################################
connection = QSqlDatabase.addDatabase('QPSQL')
connection.setHostName(host)
connection.setPort(port)
connection.setUserName(user)
connection.setPassword(password)
connection.setDatabaseName(dbname)
if not connection.isOpen(
): # Testa se a conexão esta recebendo os parametros adequadamente.
if not connection.open():
print 'Error connecting to database!'
self.iface.messageBar().pushMessage(
"Erro",
u'Error connecting to database!',
level=QgsMessageBar.CRITICAL,
duration=4)
print connection.lastError().text()
return
####################################
###### CRIAÇÃO DE MEMORY LAYER #####
####################################
layerCrs = layer.crs().authid() # Passa o formato (epsg: numeros)
flagsLayerName = layer.name() + "_flags"
flagsLayerExists = False
for l in QgsMapLayerRegistry.instance().mapLayers().values(
): # Recebe todas as camadas que estão abertas
if l.name() == flagsLayerName: # ao encontrar o nome pretendido..
self.flagsLayer = l # flagslayer vai receber o nome..
self.flagsLayerProvider = l.dataProvider()
flagsLayerExists = True # se encontrado os parametros buscados, recebe True.
break
if flagsLayerExists == False: # se não encontrado os parametros buscados, recebe False.
tempString = "Point?crs="
tempString += str(layerCrs)
self.flagsLayer = QgsVectorLayer(tempString, flagsLayerName,
"memory")
self.flagsLayerProvider = self.flagsLayer.dataProvider()
self.flagsLayerProvider.addAttributes([
QgsField("flagId", QVariant.Int),
QgsField("geomId", QVariant.String),
QgsField("motivo", QVariant.String)
])
self.flagsLayer.updateFields()
self.flagsLayer.startEditing()
ids = [feat.id() for feat in self.flagsLayer.getFeatures()]
self.flagsLayer.deleteFeatures(ids)
self.flagsLayer.commitChanges()
lista_fid = [] # Iniciando lista
for f in layer.getFeatures():
lista_fid.append(
str(f.id())
) # Guarda na lista. A lista de Feature ids passa tipo "int", foi convertido e guardado como "str".
source = layer.source().split(" ")
self.tableName = "" # Inicia vazio
layerExistsInDB = False
for i in source:
if "table=" in i or "layername=" in i: # Se encontrar os atributos pretendidos dentre todos do for
self.tableName = source[source.index(i)].split(".")[
1] # Faz split em ponto e pega a segunda parte.
self.tableName = self.tableName.replace('"', '')
layerExistsInDB = True
break
if layerExistsInDB == False:
self.iface.messageBar().pushMessage(
"Erro",
u"Provedor da camada corrente não provem do banco de dados!",
level=QgsMessageBar.CRITICAL,
duration=4)
return
geomType = layer.geometryType()
if geomType == QGis.Line:
# Busca através do SQL
sql = """
WITH result AS (SELECT points."{4}", points.anchor, (degrees
(
ST_Azimuth(points.anchor, points.pt1) - ST_Azimuth(points.anchor, points.pt2)
)::decimal + 360) % 360 as angle
FROM
(SELECT
ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-2)) as pt1,
ST_PointN("{3}", generate_series(2, ST_NPoints("{3}")-1)) as anchor,
ST_PointN("{3}", generate_series(3, ST_NPoints("{3}"))) as pt2,
linestrings."{4}" as "{4}"
FROM
(SELECT "{4}" as "{4}", (ST_Dump("{3}")).geom as "{3}"
FROM only "{0}"."{1}"
) AS linestrings WHERE ST_NPoints(linestrings."{3}") > 2 ) as points)
select distinct "{4}", ST_AsText(anchor), angle from result where (result.angle % 360) < {2} or result.angle > (360.0 - ({2} % 360.0)) and result.{4} in ({5})""".format(
self.tableSchema, self.tableName, self.angle,
self.geometryColumn, self.keyColumn, ",".join(lista_fid))
elif geomType == QGis.Polygon:
sql = """
WITH result AS (SELECT points."{4}", points.anchor, (degrees
(
ST_Azimuth(points.anchor, points.pt1) - ST_Azimuth(points.anchor, points.pt2)
)::decimal + 360) % 360 as angle
FROM
(SELECT
ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-1)) as pt1,
ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-1) % (ST_NPoints("{3}")-1)+1) as anchor,
ST_PointN("{3}", generate_series(2, ST_NPoints("{3}")) % (ST_NPoints("{3}")-1)+1) as pt2,
linestrings."{4}" as "{4}"
FROM
(SELECT "{4}" as "{4}", (ST_Dump(ST_Boundary(ST_ForceRHR((ST_Dump("{3}")).geom)))).geom as "{3}"
FROM only "{0}"."{1}"
) AS linestrings WHERE ST_NPoints(linestrings."{3}") > 2 ) as points)
select distinct "{4}", ST_AsText(anchor), angle from result where (result.angle % 360) < {2} or result.angle > (360.0 - ({2} % 360.0)) and result.{4} in ({5})""".format(
self.tableSchema, self.tableName, self.angle,
self.geometryColumn, self.keyColumn, ",".join(lista_fid))
query = QSqlQuery(sql)
self.flagsLayer.startEditing()
flagCount = 0 # iniciando contador que será referência para os IDs da camada de memória.
listaFeatures = []
while query.next():
id = query.value(0)
local = query.value(1)
angulo = query.value(2)
flagId = flagCount
print id, local, angulo
flagFeat = QgsFeature()
flagGeom = QgsGeometry.fromWkt(
local) # passa o local onde foi localizado o erro.
flagFeat.setGeometry(flagGeom)
flagFeat.initAttributes(3)
flagFeat.setAttribute(
0, flagId
) # insere o id definido para a coluna 0 da layer de memória.
flagFeat.setAttribute(
1, id
) # insere o id da geometria para a coluna 1 da layer de memória.
flagFeat.setAttribute(
2, u"Ângulo para os vértices adjacentes inferior à tolerância")
# TypeError: fromWkt(QString): argument 1 has unexpected type 'long'
# Traceback (most recent call last):
# File "/home/piangers/.qgis2/python/plugins/StartDuplic/StartDuplic.py", line 177, in run
# flagGeom = QgsGeometry.fromWkt(local) # passa o local onde foi localizado o erro.
listaFeatures.append(flagFeat)
flagCount += 1 # incrementando o contador a cada iteração
self.flagsLayerProvider.addFeatures(listaFeatures)
self.flagsLayer.commitChanges() # Aplica as alterações à camada.
QgsMapLayerRegistry.instance().addMapLayer(
self.flagsLayer) # Adicione a camada no mapa
if flagCount == 0:
QgsMapLayerRegistry.instance().removeMapLayer(self.flagsLayer.id())
self.iface.messageBar().pushMessage(
"Aviso",
u"Não foi encontrado Flags em \"" + layer.name() + "\" !",
level=QgsMessageBar.CRITICAL,
duration=4)
return
if len(query.lastError().text()) == 1:
self.iface.messageBar().pushMessage(
"Aviso",
"foram geradas " + str(flagCount) + " flags para a camada \"" +
layer.name() + "\" !",
level=QgsMessageBar.INFO,
duration=4)
else:
self.iface.messageBar().pushMessage("Erro",
u"a geração de flags falhou!",
level=QgsMessageBar.CRITICAL,
duration=4)
print query.lastError().text()
def processAlgorithm(self, parameters, context, feedback):
extent = self.getParameterValue(self.EXTENT).split(',')
hSpacing = self.getParameterValue(self.HSPACING)
vSpacing = self.getParameterValue(self.VSPACING)
hOverlay = self.getParameterValue(self.HOVERLAY)
vOverlay = self.getParameterValue(self.VOVERLAY)
crs = QgsCoordinateReferenceSystem(self.getParameterValue(self.CRS))
bbox = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
width = bbox.width()
height = bbox.height()
if hSpacing <= 0 or vSpacing <= 0:
raise GeoAlgorithmExecutionException(
self.tr('Invalid grid spacing: {0}/{1}').format(
hSpacing, vSpacing))
if hSpacing <= hOverlay or vSpacing <= vOverlay:
raise GeoAlgorithmExecutionException(
self.tr('Invalid overlay: {0}/{1}').format(hOverlay, vOverlay))
if width < hSpacing:
raise GeoAlgorithmExecutionException(
self.tr(
'Horizontal spacing is too small for the covered area'))
if height < vSpacing:
raise GeoAlgorithmExecutionException(
self.tr('Vertical spacing is too small for the covered area'))
fields = QgsFields()
fields.append(QgsField('left', QVariant.Double, '', 24, 16))
fields.append(QgsField('top', QVariant.Double, '', 24, 16))
fields.append(QgsField('right', QVariant.Double, '', 24, 16))
fields.append(QgsField('bottom', QVariant.Double, '', 24, 16))
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
fields.append(QgsField('coord', QVariant.Double, '', 24, 15))
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.LineString, crs, context)
if hOverlay > 0:
hSpace = [hSpacing - hOverlay, hOverlay]
else:
hSpace = [hSpacing, hSpacing]
if vOverlay > 0:
vSpace = [vSpacing - vOverlay, vOverlay]
else:
vSpace = [vSpacing, vSpacing]
feat = QgsFeature()
feat.initAttributes(len(fields))
count = 0
id = 1
# latitude lines
count_max = height / vSpacing
count_update = count_max * 0.10
y = bbox.yMaximum()
while y >= bbox.yMinimum():
pt1 = QgsPoint(bbox.xMinimum(), y)
pt2 = QgsPoint(bbox.xMaximum(), y)
line = QgsLineString()
line.setPoints([pt1, pt2])
feat.setGeometry(QgsGeometry(line))
feat.setAttributes([bbox.xMinimum(), y, bbox.xMaximum(), y, id, y])
writer.addFeature(feat, QgsFeatureSink.FastInsert)
y = y - vSpace[count % 2]
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(int(count / count_max * 50))
feedback.setProgress(50)
# longitude lines
# counters for progressbar - update every 5%
count = 0
count_max = width / hSpacing
count_update = count_max * 0.10
x = bbox.xMinimum()
while x <= bbox.xMaximum():
pt1 = QgsPoint(x, bbox.yMaximum())
pt2 = QgsPoint(x, bbox.yMinimum())
line = QgsLineString()
line.setPoints([pt1, pt2])
feat.setGeometry(QgsGeometry(line))
feat.setAttributes([x, bbox.yMaximum(), x, bbox.yMinimum(), id, x])
writer.addFeature(feat, QgsFeatureSink.FastInsert)
x = x + hSpace[count % 2]
id += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(50 + int(count / count_max * 50))
del writer
def epa2gis(inpname, epsg_crs):
plugin_path = os.path.dirname(__file__)
file_extension = os.path.dirname(inpname)
inpname = os.path.basename(inpname)
inp = file_extension + '/' + inpname
if len(file_extension) == 0:
inp = inpname
newpath = file_extension + '/_shapefiles_'
if not os.path.exists(newpath):
os.makedirs(newpath)
iface = qgis.utils.iface
d.LoadFile(inp)
d.BinUpdateClass()
nlinkCount = d.getBinLinkCount()
res = newpath + '\\'
saveFile = res + inpname[:len(inpname) - 4]
# Get all Sections
mixing = d.getMixingSection()
reactions = d.getReactionsSection()
sources = d.getSourcesSection()
rules = d.getRulesSection()
quality = d.getQualitySection()
curves = d.getCurvesSection()
patterns = d.getPatternsSection()
controls = d.getControlsSection()
emitters = d.getEmittersSection()
status = d.getStatusSection()
demands = d.getDemandsSection()
energy = d.getEnergySection()
optReactions = d.getReactionsOptionsSection()
times = d.getTimesSection()
report = d.getReportSection()
options = d.getOptionsSection()
# Get all Section lengths
allSections = [
len(energy),
len(optReactions),
len(demands),
len(status),
len(emitters),
len(controls),
len(patterns),
len(curves[0]),
len(quality),
len(rules),
len(sources),
len(reactions),
len(mixing),
len(times),
len(report),
len(options),
d.getBinNodeCount(),
d.getBinLinkCount()
]
ss = max(allSections)
root = QgsProject.instance().layerTreeRoot()
idx = root.insertGroup(0, inpname[:len(inpname) - 4])
xy = d.getBinNodeCoordinates()
ndCoordsID = xy[0]
x = xy[1]
y = xy[2]
vertx = xy[3]
verty = xy[4]
vertxyFinal = []
for i in range(len(vertx)):
vertxy = []
for u in range(len(vertx[i])):
vertxy.append([float(vertx[i][u]), float(verty[i][u])])
vertxyFinal.append(vertxy)
otherDemads = d.getBinNodeBaseDemandsDemSection()
ndID = d.getBinNodeNameID()
ndBaseD = d.getBinNodeBaseDemands()
ndPatID = d.getBinNodeDemandPatternID()
otherDemadsIndex = []
otherDemadsPatterns = []
for i, p in enumerate(otherDemads[1]):
otherDemadsIndex.append(ndID.index(p))
otherDemadsPatterns.append(otherDemads[2][i])
counter = collections.Counter(otherDemadsIndex)
maxCategories = 1
if counter:
maxCategories = max(counter.values())
if not ndBaseD:
ndBaseD = otherDemads[0]
# Get data of Junctions
if d.getBinNodeJunctionCount() > 0:
ndBaseTmp = np.empty((
len(ndBaseD),
maxCategories,
))
ndPatTmp = []
for t in range(0, maxCategories):
for u in range(0, len(ndBaseD)):
ndBaseTmp[u][t] = 0
ndPatTmp.append([''] * maxCategories)
for uu in range(0, len(ndBaseD)):
if d.getBinNodeBaseDemands():
ndBaseTmp[uu][0] = ndBaseD[uu]
ndPatTmp[uu][0] = ndPatID[uu]
dem_cat_tot = list(counter.values())
l = 0
for i, p in enumerate(dem_cat_tot):
for t in range(p):
demInd = otherDemadsIndex[l]
if t == 0:
ndBaseTmp[demInd][t] = ndBaseD[demInd]
ndPatTmp[demInd][t] = ndPatID[demInd]
if p > 1:
ndBaseTmp[demInd][t] = otherDemads[0][l]
ndPatTmp[demInd][t] = otherDemads[2][l]
l = l + 1
#if i > 0:
# if otherDemadsIndex[i - 1] == p:
# ndBaseTmp[p][t] = otherDemads[0][i]
# ndPatTmp[p][t] = otherDemads[2][i]
# t = t - 1
# Write Junction Shapefile
fields = ["ID", "Elevation"] # , "pattern", "demand"]
fieldsCode = [0, 1]
for u in range(0, maxCategories):
fields.append('Demand' + str(u + 1))
fields.append('Pattern' + str(u + 1))
fieldsCode.append(1)
fieldsCode.append(0)
fields.append('Desc')
fieldsCode.append(0)
posJunction = QgsVectorLayer("point?crs=" + epsg_crs, "Junctions",
"memory")
prJunction = posJunction.dataProvider()
ndBaseTmp = ndBaseTmp.tolist()
createColumnsAttrb(prJunction, fields, fieldsCode)
posJunction.startEditing()
ndEle = d.getBinNodeJunctionElevations()
ndDes = d.getBinNodeJunctionDescription()
# Get data of Pipes
# Write shapefile pipe
if nlinkCount > 0:
posPipe = QgsVectorLayer("LineString?crs=" + epsg_crs, "Pipes",
"memory")
prPipe = posPipe.dataProvider()
fields = [
"ID", "NodeFrom", "NodeTo", "Status", "Length", "Diameter",
"Roughness", "MinorLoss", "Desc"
]
fieldsCode = [0, 0, 0, 0, 1, 1, 1, 1, 0]
createColumnsAttrb(prPipe, fields, fieldsCode)
posPipe.startEditing()
pIndex = d.getBinLinkPumpIndex()
vIndex = d.getBinLinkValveIndex()
ndlConn = d.getBinNodesConnectingLinksID()
stat = d.getBinLinkInitialStatus()
ch = 0
linkID = d.getBinLinkNameID()
linkLengths = d.getBinLinkLength()
linkDiameters = d.getBinLinkDiameter()
linkRough = d.getBinLinkRoughnessCoeff()
linkMinorloss = d.getBinLinkMinorLossCoeff()
linkDescription = d.getBinLinkPipeDescription()
# Write Tank Shapefile and get tank data
posTank = QgsVectorLayer("point?crs=" + epsg_crs, "Tanks", "memory")
prTank = posTank.dataProvider()
fields = [
"ID", "Elevation", "InitLevel", "MinLevel", "MaxLevel", "Diameter",
"MinVolume", "VolumeCurve", "Desc"
]
fieldsCode = [0, 1, 1, 1, 1, 1, 1, 0, 0]
createColumnsAttrb(prTank, fields, fieldsCode)
posTank.startEditing()
if d.getBinNodeTankCount() > 0:
ndTankelevation = d.getBinNodeTankElevations()
initiallev = d.getBinNodeTankInitialLevel()
minimumlev = d.getBinNodeTankMinimumWaterLevel()
maximumlev = d.getBinNodeTankMaximumWaterLevel()
diameter = d.getBinNodeTankDiameter()
minimumvol = d.getBinNodeTankMinimumWaterVolume()
volumecurv = d.getBinNodeTankVolumeCurveID()
ndTankID = d.getBinNodeTankNameID()
ndTankDescription = d.getBinNodeTankDescription()
# Write Reservoir Shapefile
posReservoirs = QgsVectorLayer("point?crs=" + epsg_crs, "Reservoirs",
"memory")
prReservoirs = posReservoirs.dataProvider()
fields = ["ID", "Head", "Desc"]
fieldsCode = [0, 1, 0]
createColumnsAttrb(prReservoirs, fields, fieldsCode)
head = d.getBinNodeReservoirElevations()
ndReservoirDescription = d.getBinNodeReservoirDescription()
posReservoirs.startEditing()
if times:
posTimes = QgsVectorLayer("point?crs=" + epsg_crs, "Times", "memory")
prTimes = posTimes.dataProvider()
if energy:
posE = QgsVectorLayer("point?crs=" + epsg_crs, "Energy", "memory")
prE = posE.dataProvider()
if report:
posRep = QgsVectorLayer("point?crs=" + epsg_crs, "Report", "memory")
prRep = posRep.dataProvider()
if options:
posOpt = QgsVectorLayer("point?crs=" + epsg_crs, "Options", "memory")
prOpt = posOpt.dataProvider()
if optReactions:
posO = QgsVectorLayer("point?crs=" + epsg_crs, "Reactions", "memory")
prO = posO.dataProvider()
ppE = []
ppO = []
ppTimes = []
ppRep = []
ppOpt = []
ppMix = []
ppReactions = []
ppSourc = []
ppRul = []
ppPat = []
ppQual = []
ppDem = []
ppStat = []
ppEmit = []
ppCont = []
ppCurv = []
for i in range(ss):
if i < d.getBinNodeJunctionCount():
try:
ndIndexNew = ndCoordsID.index(ndID[i])
featJ = QgsFeature()
point = QgsPointXY(float(x[ndIndexNew]), float(y[ndIndexNew]))
featJ.initAttributes(3 + len(ndBaseTmp[0]) * 2)
featJ.setGeometry(QgsGeometry.fromPointXY(point))
featJ.setAttribute(0, ndID[i])
featJ.setAttribute(1, ndEle[i])
w = 2
for j in range(0, len(ndBaseTmp[0])):
featJ.setAttribute(w, ndBaseTmp[i][j])
featJ.setAttribute(w + 1, ndPatTmp[i][j])
w = w + 2
featJ.setAttribute(w, ndDes[i])
prJunction.addFeatures([featJ])
except:
pass
if i < nlinkCount:
if len(stat) == i:
ch = 1
if ch == 1:
stat.append('OPEN')
try:
x1 = x[ndCoordsID.index(d.getBinLinkFromNode()[i])]
y1 = y[ndCoordsID.index(d.getBinLinkFromNode()[i])]
x2 = x[ndCoordsID.index(d.getBinLinkToNode()[i])]
y2 = y[ndCoordsID.index(d.getBinLinkToNode()[i])]
if i in pIndex:
pass
elif i in vIndex:
pass
else:
point1 = QgsPointXY(float(x1), float(y1))
point2 = QgsPointXY(float(x2), float(y2))
featPipe = QgsFeature()
if vertx[i]:
parts = []
parts.append(point1)
for mm in range(len(vertxyFinal[i])):
a = vertxyFinal[i][mm]
parts.append(QgsPointXY(a[0], a[1]))
parts.append(point2)
featPipe.setGeometry(
(QgsGeometry.fromPolylineXY(parts)))
else:
featPipe.setGeometry(
QgsGeometry.fromPolylineXY([point1, point2]))
featPipe.setAttributes([
linkID[i], ndlConn[0][i], ndlConn[1][i], stat[i],
linkLengths[i], linkDiameters[i], linkRough[i],
linkMinorloss[i], linkDescription[i]
])
prPipe.addFeatures([featPipe])
except:
pass
if i < d.getBinNodeTankCount():
p = d.getBinNodeTankIndex()[i] - 1
try:
ndIndexNew = ndCoordsID.index(ndID[p])
except:
continue
featTank = QgsFeature()
point = QgsPointXY(float(x[ndIndexNew]), float(y[ndIndexNew]))
featTank.setGeometry(QgsGeometry.fromPointXY(point))
featTank.setAttributes([
ndTankID[i], ndTankelevation[i], initiallev[i], minimumlev[i],
maximumlev[i], diameter[i], minimumvol[i], volumecurv[i],
ndTankDescription[i]
])
prTank.addFeatures([featTank])
if i < d.getBinNodeReservoirCount():
p = d.getBinNodeReservoirIndex()[i] - 1
try:
ndIndexNew = ndCoordsID.index(ndID[p])
except:
continue
feature = QgsFeature()
point = QgsPointXY(float(x[ndIndexNew]), float(y[ndIndexNew]))
feature.setGeometry(QgsGeometry.fromPointXY(point))
feature.setAttributes(
[ndID[p], head[i], ndReservoirDescription[i]])
prReservoirs.addFeatures([feature])
if i < allSections[12]:
if len(mixing[i]) == 3:
ppMix.append([mixing[i][0], mixing[i][1], mixing[i][2]])
else:
ppMix.append([mixing[i][0], mixing[i][1]])
if i < allSections[11]:
ppReactions.append(
[reactions[i][0], reactions[i][1], reactions[i][2]])
if i < allSections[10]:
if len(sources[i]) == 4:
ppSourc.append([
sources[i][0], sources[i][1], sources[i][2], sources[i][3]
])
elif len(sources[i]) == 3:
ppSourc.append([sources[i][0], sources[i][1], sources[i][2]])
else:
ppSourc.append([sources[i][0], sources[i][1]])
if i < allSections[9]:
if len(rules[i]) > 2:
ppRul.append([
rules[i][0][1][1],
rules[i][1][0] + rules[i][2][0] + rules[i][3][0]
])
if i < allSections[8]:
ppQual.append([quality[i][0], quality[i][1]])
if i < allSections[7]:
ppCurv.append([
str(curves[0][i][0]),
str(curves[0][i][1]),
str(curves[0][i][2]),
str(curves[1][i])
])
if i < allSections[6]:
ppPat.append([patterns[i][0], str(patterns[i][1])])
if i < allSections[5]:
ppCont.append([controls[i]])
if i < allSections[4]:
ppEmit.append([emitters[i][0], emitters[i][1]])
if i < allSections[3]:
ppStat.append([status[i][0], status[i][1]])
if i < allSections[2]:
if len(demands[i]) > 2:
ppDem.append([demands[i][0], demands[i][1], demands[i][2]])
if i < allSections[0]:
mm = energy[i][0]
if mm.upper() == "GLOBAL":
prE.addAttributes(
[QgsField("Global" + energy[i][1], QVariant.String)])
if len(energy[i]) > 2:
ppE.append(energy[i][2])
else:
ppE.append('')
if mm.upper() == "PUMP":
prE.addAttributes([QgsField("Pump", QVariant.String)])
if len(energy[i]) > 2:
ppE.append(energy[i][1] + ' ' + energy[i][2])
else:
ppE.append(energy[i][1])
elif mm.upper() == "DEMAND":
if energy[i][1].upper() == "CHARGE":
prE.addAttributes([QgsField("DemCharge", QVariant.String)])
if len(energy[i]) > 2:
ppE.append(energy[i][2])
if i < allSections[1]:
mm = optReactions[i][0]
if mm.upper() == "ORDER":
prO.addAttributes(
[QgsField("Order" + optReactions[i][1], QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][2])
else:
ppO.append('')
elif mm.upper() == "GLOBAL":
prO.addAttributes(
[QgsField("Global" + optReactions[i][1], QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][2])
else:
ppO.append('')
elif mm.upper() == "BULK":
prO.addAttributes([QgsField("Bulk", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][1] + ' ' + optReactions[i][2])
else:
ppO.append(optReactions[i][1])
elif mm.upper() == "WALL":
prO.addAttributes([QgsField("Wall", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][1] + ' ' + optReactions[i][2])
else:
ppO.append(optReactions[i][1])
elif mm.upper() == "TANK":
prO.addAttributes([QgsField("Tank", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][1] + ' ' + optReactions[i][2])
else:
ppO.append(optReactions[i][1])
elif mm.upper() == "LIMITING":
if optReactions[i][1].upper() == "POTENTIAL":
prO.addAttributes([QgsField("LimPotent", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][2])
elif mm.upper() == "ROUGHNESS":
if optReactions[i][1].upper() == "CORRELATION":
prO.addAttributes([QgsField("RoughCorr", QVariant.String)])
if len(optReactions[i]) > 2:
ppO.append(optReactions[i][2])
if i < allSections[13]:
mm = times[i][0]
if mm.upper() == "DURATION":
prTimes.addAttributes([QgsField("Duration", QVariant.String)])
ppTimes.append(times[i][1])
if mm.upper() == "HYDRAULIC":
prTimes.addAttributes([QgsField("HydStep", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "QUALITY":
prTimes.addAttributes([QgsField("QualStep", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "RULE":
prTimes.addAttributes([QgsField("RuleStep", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "PATTERN":
if times[i][1].upper() == "TIMESTEP":
prTimes.addAttributes(
[QgsField("PatStep", QVariant.String)])
ppTimes.append(times[i][2])
if times[i][1].upper() == "START":
prTimes.addAttributes(
[QgsField("PatStart", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "REPORT":
if times[i][1].upper() == "TIMESTEP":
prTimes.addAttributes(
[QgsField("RepStep", QVariant.String)])
ppTimes.append(times[i][2])
if times[i][1].upper() == "START":
prTimes.addAttributes(
[QgsField("RepStart", QVariant.String)])
ppTimes.append(times[i][2])
elif mm.upper() == "START":
if times[i][1].upper() == "CLOCKTIME":
prTimes.addAttributes(
[QgsField("StartClock", QVariant.String)])
if len(times[i]) > 3:
ppTimes.append(times[i][2] + ' ' + times[i][3])
else:
ppTimes.append(times[i][2])
elif mm.upper() == "STATISTIC":
prTimes.addAttributes([QgsField("Statistic", QVariant.String)])
if times[i][1].upper() == 'NONE' or times[i][1].upper() == 'AVERAGE' or times[i][1].upper() \
== 'MINIMUM' or times[i][1].upper() == 'MAXIMUM' or times[i][1].upper() == 'RANGE':
ppTimes.append(times[i][1])
if i < allSections[14]:
mm = report[i][0]
if mm.upper() == "PAGESIZE":
prRep.addAttributes([QgsField("PageSize", QVariant.String)])
ppRep.append(report[i][1])
if mm.upper() == "FILE":
prRep.addAttributes([QgsField("FileName", QVariant.String)])
ppRep.append(report[i][1])
elif mm.upper() == "STATUS":
prRep.addAttributes([QgsField("Status", QVariant.String)])
ppRep.append(report[i][1])
elif mm.upper() == "SUMMARY":
prRep.addAttributes([QgsField("Summary", QVariant.String)])
ppRep.append(report[i][1])
elif mm.upper() == "ENERGY":
prRep.addAttributes([QgsField("Energy", QVariant.String)])
ppRep.append(report[i][1])
elif mm.upper() == "NODES":
prRep.addAttributes([QgsField("Nodes", QVariant.String)])
if len(report[i]) > 2:
ppRep.append(report[i][1] + ' ' + report[i][2])
else:
ppRep.append(report[i][1])
elif mm.upper() == "LINKS":
prRep.addAttributes([QgsField("Links", QVariant.String)])
if len(report[i]) > 2:
ppRep.append(report[i][1] + ' ' + report[i][2])
else:
ppRep.append(report[i][1])
else:
prRep.addAttributes([QgsField(mm, QVariant.String)])
if len(report[i]) > 2:
ppRep.append(report[i][1] + ' ' + report[i][2])
else:
ppRep.append(report[i][1])
if i < allSections[15]:
mm = options[i][0]
if mm.upper() == "UNITS":
prOpt.addAttributes([QgsField("Units", QVariant.String)])
ppOpt.append(options[i][1])
if mm.upper() == "HYDRAULICS":
prOpt.addAttributes([QgsField("Hydraulics", QVariant.String)])
if len(options[i]) > 2:
ppOpt.append(options[i][1] + ' ' + options[i][2])
else:
ppOpt.append(options[i][1])
elif mm.upper() == "QUALITY":
prOpt.addAttributes([QgsField("Quality", QVariant.String)])
if len(options[i]) > 2:
ppOpt.append(options[i][1] + ' ' + options[i][2])
elif len(options[i]) > 3:
ppOpt.append(options[i][1] + ' ' + options[i][2] + ' ' +
options[i][3])
else:
ppOpt.append(options[i][1])
elif mm.upper() == "VISCOSITY":
prOpt.addAttributes([QgsField("Viscosity", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "DIFFUSIVITY":
prOpt.addAttributes([QgsField("Diffusivity", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "SPECIFIC":
if options[i][1].upper() == "GRAVITY":
prOpt.addAttributes(
[QgsField("SpecGrav", QVariant.String)])
ppOpt.append(options[i][2])
elif mm.upper() == "TRIALS":
prOpt.addAttributes([QgsField("Trials", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "HEADLOSS":
prOpt.addAttributes([QgsField("Headloss", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "ACCURACY":
prOpt.addAttributes([QgsField("Accuracy", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "UNBALANCED":
prOpt.addAttributes([QgsField("Unbalanced", QVariant.String)])
if len(options[i]) > 2:
ppOpt.append(options[i][1] + ' ' + options[i][2])
else:
ppOpt.append(options[i][1])
elif mm.upper() == "PATTERN":
prOpt.addAttributes([QgsField("PatID", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "TOLERANCE":
prOpt.addAttributes([QgsField("Tolerance", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "MAP":
prOpt.addAttributes([QgsField("Map", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "DEMAND":
if options[i][1].upper() == "MULTIPLIER":
prOpt.addAttributes([QgsField("DemMult", QVariant.String)])
ppOpt.append(options[i][2])
elif mm.upper() == "EMITTER":
if options[i][1].upper() == "EXPONENT":
prOpt.addAttributes([QgsField("EmitExp", QVariant.String)])
ppOpt.append(options[i][2])
elif mm.upper() == "CHECKFREQ":
prOpt.addAttributes([QgsField("CheckFreq", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "MAXCHECK":
prOpt.addAttributes([QgsField("MaxCheck", QVariant.String)])
ppOpt.append(options[i][1])
elif mm.upper() == "DAMPLIMIT":
prOpt.addAttributes([QgsField("DampLimit", QVariant.String)])
ppOpt.append(options[i][1])
try:
writeDBF(posOpt, [ppOpt], prOpt, saveFile, inpname, "_OPTIONS", idx)
writeDBF(posRep, [ppRep], prRep, saveFile, inpname, "_REPORT", idx)
#if times:
writeDBF(posTimes, [ppTimes], prTimes, saveFile, inpname, "_TIMES",
idx)
#if energy:
writeDBF(posE, [ppE], prE, saveFile, inpname, "_ENERGY", idx)
#if optReactions:
writeDBF(posO, [ppO], prO, saveFile, inpname, "_REACTIONS", idx)
posMix = QgsVectorLayer("point?crs=" + epsg_crs, "Mixing", "memory")
prMix = posMix.dataProvider()
fields = ["Tank_ID", "Model", "Fraction"]
fieldsCode = [0, 0, 1] # 0 String, 1 Double
createColumnsAttrb(prMix, fields, fieldsCode)
writeDBF(posMix, ppMix, prMix, saveFile, inpname, "_MIXING", idx)
posReact = QgsVectorLayer("point?crs=" + epsg_crs, "ReactionsI",
"memory")
prReact = posReact.dataProvider()
fields = ["Type", "Pipe/Tank", "Coeff."]
fieldsCode = [0, 0, 1]
createColumnsAttrb(prReact, fields, fieldsCode)
writeDBF(posReact, ppReactions, prReact, saveFile, inpname,
"_REACTIONS_I", idx)
posSourc = QgsVectorLayer("point?crs=" + epsg_crs, "Sources", "memory")
prSourc = posSourc.dataProvider()
fields = ["Node_ID", "Type", "Strength", "Pattern"]
fieldsCode = [0, 0, 1, 0]
createColumnsAttrb(prSourc, fields, fieldsCode)
writeDBF(posSourc, ppSourc, prSourc, saveFile, inpname, "_SOURCES",
idx)
posRul = QgsVectorLayer("point?crs=" + epsg_crs, "Rules", "memory")
prRul = posRul.dataProvider()
fields = ["Rule_ID", "Rule"]
fieldsCode = [0, 0]
createColumnsAttrb(prRul, fields, fieldsCode)
writeDBF(posRul, ppRul, prRul, saveFile, inpname, "_RULES", idx)
posQual = QgsVectorLayer("point?crs=" + epsg_crs, "Sources", "memory")
prQual = posQual.dataProvider()
fields = ["Node_ID", "Init_Qual"]
fieldsCode = [0, 1]
createColumnsAttrb(prQual, fields, fieldsCode)
writeDBF(posQual, ppQual, prQual, saveFile, inpname, "_QUALITY", idx)
posStat = QgsVectorLayer("point?crs=" + epsg_crs, "Status", "memory")
prStat = posStat.dataProvider()
fields = ["Link_ID", "Status/Setting"]
fieldsCode = [0, 0]
createColumnsAttrb(prStat, fields, fieldsCode)
writeDBF(posStat, ppStat, prStat, saveFile, inpname, "_STATUS", idx)
posEmit = QgsVectorLayer("point?crs=" + epsg_crs, "Emitters", "memory")
prEmit = posEmit.dataProvider()
fields = ["Junc_ID", "Coeff."]
fieldsCode = [0, 1]
createColumnsAttrb(prEmit, fields, fieldsCode)
writeDBF(posEmit, ppEmit, prEmit, saveFile, inpname, "_EMITTERS", idx)
posCont = QgsVectorLayer("point?crs=" + epsg_crs, "Controls", "memory")
prCont = posCont.dataProvider()
fields = ["Controls"]
fieldsCode = [0]
createColumnsAttrb(prCont, fields, fieldsCode)
writeDBF(posCont, ppCont, prCont, saveFile, inpname, "_CONTROLS", idx)
posPat = QgsVectorLayer("point?crs=" + epsg_crs, "Patterns", "memory")
prPat = posPat.dataProvider()
fields = ["Pattern_ID", "Multipliers"]
fieldsCode = [0, 0]
createColumnsAttrb(prPat, fields, fieldsCode)
writeDBF(posPat, ppPat, prPat, saveFile, inpname, "_PATTERNS", idx)
posCurv = QgsVectorLayer("point?crs=" + epsg_crs, "Curves", "memory")
prCurv = posCurv.dataProvider()
fields = ["Curve_ID", "X-Value", "Y-Value", "Type"]
fieldsCode = [0, 0, 0, 0]
createColumnsAttrb(prCurv, fields, fieldsCode)
writeDBF(posCurv, ppCurv, prCurv, saveFile, inpname, "_CURVES", idx)
except:
pass
# Write Valve Shapefile
posValve = QgsVectorLayer("LineString?crs=" + epsg_crs, "Valve", "memory")
prValve = posValve.dataProvider()
fields = [
"ID", "NodeFrom", "NodeTo", "Diameter", "Type", "Setting", "MinorLoss",
"Desc"
]
fieldsCode = [0, 0, 0, 1, 0, 1, 1, 0]
createColumnsAttrb(prValve, fields, fieldsCode)
posValve.startEditing()
if d.getBinLinkValveCount() > 0:
linkID = d.getBinLinkValveNameID()
linkType = d.getBinLinkValveType() # valve type
linkDiameter = d.getBinLinkValveDiameters()
linkInitSett = d.getBinLinkValveSetting() # BinLinkValveSetting
linkMinorloss = d.getBinLinkValveMinorLoss()
linkDescription = d.getBinLinkValveDescription()
for i, p in enumerate(d.getBinLinkValveIndex()):
try:
point1 = QgsPointXY(
float(x[ndCoordsID.index(d.getBinLinkFromNode()[p])]),
float(y[ndCoordsID.index(d.getBinLinkFromNode()[p])]))
point2 = QgsPointXY(
float(x[ndCoordsID.index(d.getBinLinkToNode()[p])]),
float(y[ndCoordsID.index(d.getBinLinkToNode()[p])]))
except:
continue
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPolylineXY([point1, point2]))
feature.setAttributes([
linkID[i], ndlConn[0][p], ndlConn[1][p], linkDiameter[i],
linkType[i], linkInitSett[i], linkMinorloss[i],
linkDescription[i]
])
prValve.addFeatures([feature])
QgsVectorFileWriter.writeAsVectorFormat(
posValve, saveFile + "_valves" + '.shp', "System",
QgsCoordinateReferenceSystem(posValve.crs().authid()),
"ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_valves" + '.shp',
inpname[:len(inpname) - 4] + "_valves", "ogr")
QgsProject.instance().addMapLayer(ll, False)
nvalves = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, nvalves)
nvalves.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'valvesline' + ".qml")
ll.triggerRepaint()
# Write Pump Shapefile
posPump = QgsVectorLayer("LineString?crs=" + epsg_crs, "Pump", "memory")
prPump = posPump.dataProvider()
fields = ["ID", "NodeFrom", "NodeTo", "Power", "Pattern", "Curve", "Desc"]
fieldsCode = [0, 0, 0, 0, 0, 0, 0]
createColumnsAttrb(prPump, fields, fieldsCode)
posPump.startEditing()
if d.getBinLinkPumpCount() > 0:
curveXY = d.getBinCurvesXY()
curvesID = d.getBinCurvesNameID()
a = curvesID
b = []
for l in a:
if l not in b:
b.append(l)
curvesIDunique = b
CurvesTmpIndices = []
for p in range(0, len(curvesIDunique)):
CurvesTmpIndices.append(curvesID.count(curvesIDunique[p]))
curveIndices = []
Curve = d.getBinCurvesNameID()
for i in range(len(Curve)):
curveIndices.append(curvesIDunique.index(Curve[i]))
if d.getBinCurveCount():
#CurvesTmpIndicesFinal = [CurvesTmpIndices[index] for index in curveIndices]
CurvesTmp = [''] * len(curvesIDunique)
i = 0
for u in range(d.getBinCurveCount()):
if u < d.getBinLinkPumpCount():
fields.append('Head' + str(u + 1))
fields.append('Flow' + str(u + 1))
fieldsCode.append(1)
fieldsCode.append(1)
tmp1 = []
for p in range(CurvesTmpIndices[u]):
tmp1.append([curveXY[i][0], curveXY[i][1]])
i = i + 1
CurvesTmp[u] = tmp1
createColumnsAttrb(prPump, fields, fieldsCode)
chPowerPump = d.getBinLinkPumpPower()
pumpID = d.getBinLinkPumpNameID()
patternsIDs = d.getBinLinkPumpPatterns()
ppatt = d.getBinLinkPumpPatternsPumpID()
linkID = d.getBinLinkNameID()
pumpdescription = d.getBinLinkPumpDescription()
for i, p in enumerate(d.getBinLinkPumpIndex()):
Curve = []
power = []
pattern = []
pumpNameIDPower = d.getBinLinkPumpNameIDPower()
if len(pumpNameIDPower) > 0:
for uu in range(0, len(pumpNameIDPower)):
if pumpNameIDPower[uu] == pumpID[i]:
power = chPowerPump[uu]
if len(patternsIDs) > 0:
for uu in range(0, len(ppatt)):
if ppatt[uu] == pumpID[i]:
pattern = patternsIDs[uu]
try:
point1 = QgsPointXY(
float(x[ndCoordsID.index(d.getBinLinkFromNode()[p])]),
float(y[ndCoordsID.index(d.getBinLinkFromNode()[p])]))
point2 = QgsPointXY(
float(x[ndCoordsID.index(d.getBinLinkToNode()[p])]),
float(y[ndCoordsID.index(d.getBinLinkToNode()[p])]))
except:
continue
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPolylineXY([point1, point2]))
if not Curve:
Curve = 'NULL'
if not power:
power = 'NULL'
if not pattern:
pattern = 'NULL'
if d.getBinCurveCount() > 0:
try:
Curve = d.getBinLinkPumpCurveNameID()[i]
curveIndex = curvesIDunique.index(Curve)
except:
Curve = ''
feature.initAttributes(7 + sum(CurvesTmpIndices) * 2 + 1)
feature.setAttribute(0, linkID[p])
feature.setAttribute(1, ndlConn[0][p])
feature.setAttribute(2, ndlConn[1][p])
feature.setAttribute(3, power)
feature.setAttribute(4, pattern)
feature.setAttribute(5, Curve)
feature.setAttribute(6, pumpdescription[i])
if 'curveIndex' in locals():
if d.getBinCurveCount() == 1:
w = 7
for p in range(CurvesTmpIndices[curveIndex]):
feature.setAttribute(w, CurvesTmp[curveIndex][p][0])
feature.setAttribute(w + 1,
CurvesTmp[curveIndex][p][1])
w = w + 2
for j in range(d.getBinCurveCount() - 1):
w = 7
for p in range(CurvesTmpIndices[curveIndex]):
feature.setAttribute(w, CurvesTmp[curveIndex][p][0])
feature.setAttribute(w + 1,
CurvesTmp[curveIndex][p][1])
w = w + 2
prPump.addFeatures([feature])
QgsVectorFileWriter.writeAsVectorFormat(
posPump, saveFile + "_pumps" + '.shp', "System",
QgsCoordinateReferenceSystem(posPump.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_pumps" + '.shp',
inpname[:len(inpname) - 4] + "_pumps", "ogr")
QgsProject.instance().addMapLayer(ll, False)
npump = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, npump)
npump.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'pumpsline' + ".qml")
ll.triggerRepaint()
QgsVectorFileWriter.writeAsVectorFormat(
posPipe, saveFile + "_pipes" + '.shp', "System",
QgsCoordinateReferenceSystem(posPipe.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_pipes" + '.shp',
inpname[:len(inpname) - 4] + "_pipes", "ogr")
QgsProject.instance().addMapLayer(ll, False)
npipe = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, npipe)
npipe.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'pipes' + ".qml")
ll.triggerRepaint()
iface.mapCanvas().setExtent(ll.extent())
QgsVectorFileWriter.writeAsVectorFormat(
posJunction, saveFile + "_junctions" + '.shp', "System",
QgsCoordinateReferenceSystem(posJunction.crs().authid()),
"ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_junctions" + '.shp',
inpname[:len(inpname) - 4] + "_junctions", "ogr")
QgsProject.instance().addMapLayer(ll, False)
njunc = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, njunc)
njunc.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'junctions' + ".qml")
ll.triggerRepaint()
QgsVectorFileWriter.writeAsVectorFormat(
posTank, saveFile + "_tanks" + '.shp', "System",
QgsCoordinateReferenceSystem(posTank.crs().authid()), "ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_tanks" + '.shp',
inpname[:len(inpname) - 4] + "_tanks", "ogr")
QgsProject.instance().addMapLayer(ll, False)
ntanks = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, ntanks)
ntanks.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'tanks' + ".qml")
ll.triggerRepaint()
QgsVectorFileWriter.writeAsVectorFormat(
posReservoirs, saveFile + "_reservoirs" + '.shp', "System",
QgsCoordinateReferenceSystem(posReservoirs.crs().authid()),
"ESRI Shapefile")
ll = QgsVectorLayer(saveFile + "_reservoirs" + '.shp',
inpname[:len(inpname) - 4] + "_reservoirs", "ogr")
QgsProject.instance().addMapLayer(ll, False)
nres = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, nres)
nres.setCustomProperty("showFeatureCount", True)
ll.loadNamedStyle(plugin_path + "/qmls/" + 'reservoirs' + ".qml")
ll.triggerRepaint()
def processAlgorithm(self, parameters, context, feedback):
extent = self.getParameterValue(self.EXTENT).split(',')
xSpace = self.getParameterValue(self.STEP_X)
ySpace = self.getParameterValue(self.STEP_Y)
bbox = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
mapCRS = iface.mapCanvas().mapSettings().destinationCrs()
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
fields.append(QgsField('coord', QVariant.Double, '', 24, 15))
fieldCount = 2
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(
fields, QgsWkbTypes.LineString, mapCRS, context)
feat = QgsFeature()
feat.initAttributes(fieldCount)
feat.setFields(fields)
geom = QgsGeometry()
idVar = 0
count = 0
count_max = (bbox.yMaximum() - bbox.yMinimum()) / ySpace
count_update = count_max * 0.10
y = bbox.yMaximum()
while y >= bbox.yMinimum():
pt1 = QgsPointXY(bbox.xMinimum(), y)
pt2 = QgsPointXY(bbox.xMaximum(), y)
line = [pt1, pt2]
feat.setGeometry(geom.fromPolyline(line))
feat.setAttribute(0, idVar)
feat.setAttribute(1, y)
writer.addFeature(feat)
y = y - ySpace
idVar += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(int(count / count_max * 50))
feedback.setProgress(50)
# counters for progressbar - update every 5%
count = 0
count_max = (bbox.xMaximum() - bbox.xMinimum()) / xSpace
count_update = count_max * 0.10
x = bbox.xMinimum()
while x <= bbox.xMaximum():
pt1 = QgsPointXY(x, bbox.yMaximum())
pt2 = QgsPointXY(x, bbox.yMinimum())
line = [pt1, pt2]
feat.setGeometry(geom.fromPolyline(line))
feat.setAttribute(0, idVar)
feat.setAttribute(1, x)
writer.addFeature(feat)
x = x + xSpace
idVar += 1
count += 1
if int(math.fmod(count, count_update)) == 0:
feedback.setProgress(50 + int(count / count_max * 50))
del writer
def legend_test(self):
self.atlas_map.setAtlasDriven(True)
self.atlas_map.setAtlasScalingMode(QgsLayoutItemMap.Auto)
self.atlas_map.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer(
"Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)",
"points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRenderer("attr", [
QgsRendererCategory(
1,
QgsMarkerSymbol.createSimple({
"color": "255,0,0",
'outline_color': 'black'
}), "red"),
QgsRendererCategory(
2,
QgsMarkerSymbol.createSimple({
"color": "0,0,255",
'outline_color': 'black'
}), "blue")
])
ptLayer.setRenderer(r)
QgsProject.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.layers
layers = [ptLayer] + layers
self.atlas_map.setLayers(layers)
self.overview.setLayers(layers)
# add a legend
legend = QgsLayoutItemLegend(self.layout)
legend.setTitle("Legend")
legend.attemptMove(QgsLayoutPoint(200, 100))
# sets the legend filter parameter
legend.setLinkedMap(self.atlas_map)
legend.setLegendFilterOutAtlas(True)
self.layout.addLayoutItem(legend)
self.atlas.beginRender()
self.atlas.seekTo(0)
self.mLabel1.adjustSizeToText()
checker = QgsLayoutChecker('atlas_legend', self.layout)
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.assertTrue(myTestResult, myMessage)
self.atlas.endRender()
# restore state
self.atlas_map.setLayers([layers[1]])
self.layout.removeLayoutItem(legend)
QgsProject.instance().removeMapLayer(ptLayer.id())
def generate_sampling_points(self, pixel_values, number_of_samples,
min_distance, neighbor_aggregation,
attempts_by_sampling, progress_bar,
random_seed):
"""Some code base from (by Alexander Bruy):
https://github.com/qgis/QGIS/blob/release-2_18/python/plugins/processing/algs/qgis/RandomPointsExtent.py
"""
self.pixel_values = pixel_values
self.number_of_samples = number_of_samples # desired
self.total_of_samples = None # total generated
self.min_distance = min_distance
self.neighbor_aggregation = neighbor_aggregation
progress_bar.setValue(0) # init progress bar
self.ThematicR_boundaries = QgsGeometry().fromRect(
self.ThematicR.extent())
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
thematic_CRS = self.ThematicR.qgs_layer.crs()
file_format = \
"GPKG" if self.output_file.endswith(".gpkg") else "ESRI Shapefile" if self.output_file.endswith(".shp") else None
writer = QgsVectorFileWriter(self.output_file, "System", fields,
QgsWkbTypes.Point, thematic_CRS,
file_format)
if self.sampling_type == "simple":
total_of_samples = self.number_of_samples
if self.sampling_type == "stratified":
total_of_samples = sum(self.number_of_samples)
self.samples_in_categories = [0] * len(
self.number_of_samples) # total generated by categories
nPoints = 0
nIterations = 0
self.index = QgsSpatialIndex()
if attempts_by_sampling:
maxIterations = total_of_samples * attempts_by_sampling
else:
maxIterations = float('Inf')
# init the random sampling seed
self.random_seed = random_seed
random.seed(self.random_seed)
points_generated = []
while nIterations < maxIterations and nPoints < total_of_samples:
random_sampling_point = RandomPoint(self.ThematicR.extent())
# checks to the sampling point, else discard and continue
if not self.check_sampling_point(random_sampling_point):
nIterations += 1
continue
if self.sampling_type == "stratified":
self.samples_in_categories[
random_sampling_point.index_pixel_value] += 1
points_generated.append(random_sampling_point)
# it requires tmp save the point to check min distance for the next sample
f = QgsFeature(nPoints)
f.setGeometry(random_sampling_point.QgsGeom)
self.index.insertFeature(f)
self.points[nPoints] = random_sampling_point.QgsPnt
nPoints += 1
nIterations += 1
# update progress bar
progress_bar.setValue(int(nPoints))
# guarantee the random order for the classification
random.shuffle(points_generated)
self.points = dict() # restart
for num_point, point_generated in enumerate(points_generated):
# random sampling point passed the checks, save it
f = QgsFeature()
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', num_point + 1)
f.setGeometry(point_generated.QgsGeom)
writer.addFeature(f)
self.points[num_point] = point_generated.QgsPnt
# save the total point generated
self.total_of_samples = len(points_generated)
del writer, self.index
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
pointCount = self.parameterAsDouble(parameters, self.POINTS_NUMBER,
context)
minDistance = self.parameterAsDouble(parameters, self.MIN_DISTANCE,
context)
bbox = source.sourceExtent()
sourceIndex = QgsSpatialIndex(source, feedback)
fields = QgsFields()
fields.append(QgsField('id', QVariant.Int, '', 10, 0))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, fields,
QgsWkbTypes.Point,
source.sourceCrs())
nPoints = 0
nIterations = 0
maxIterations = pointCount * 200
total = 100.0 / pointCount if pointCount else 1
index = QgsSpatialIndex()
points = dict()
random.seed()
while nIterations < maxIterations and nPoints < pointCount:
if feedback.isCanceled():
break
rx = bbox.xMinimum() + bbox.width() * random.random()
ry = bbox.yMinimum() + bbox.height() * random.random()
p = QgsPointXY(rx, ry)
geom = QgsGeometry.fromPointXY(p)
ids = sourceIndex.intersects(geom.buffer(5, 5).boundingBox())
if len(ids) > 0 and \
vector.checkMinDistance(p, index, minDistance, points):
request = QgsFeatureRequest().setFilterFids(
ids).setSubsetOfAttributes([])
for f in source.getFeatures(request):
if feedback.isCanceled():
break
tmpGeom = f.geometry()
if geom.within(tmpGeom):
f = QgsFeature(nPoints)
f.initAttributes(1)
f.setFields(fields)
f.setAttribute('id', nPoints)
f.setGeometry(geom)
sink.addFeature(f, QgsFeatureSink.FastInsert)
index.insertFeature(f)
points[nPoints] = p
nPoints += 1
feedback.setProgress(int(nPoints * total))
nIterations += 1
if nPoints < pointCount:
feedback.pushInfo(
self.tr(
'Could not generate requested number of random points. '
'Maximum number of attempts exceeded.'))
return {self.OUTPUT: dest_id}
def run(self):
##################################
###### PEGA A LAYER ATIVA ########
##################################
layer = self.iface.activeLayer()
if not layer:
self.iface.messageBar().pushMessage("Erro", u"Esperando uma Active Layer!", level=QgsMessageBar.CRITICAL, duration=4)
return
if layer.featureCount() == 0:
self.iface.messageBar().pushMessage("Erro", u"a camada não possui feições!", level=QgsMessageBar.CRITICAL, duration=4)
return
parametros = layer.source().split(" ") # recebe todos os parametros em uma lista ( senha, porta, password etc..)
####################################
###### INICIANDO CONEXÃO DB ########
####################################
# Outra opção para isso, seria usar ex: self.dbname.. self.host.. etc.. direto dentro do laço for.
dbname = ""
host = ""
port = 0
user = ""
password = ""
for i in parametros:
part = i.split("=")
# Recebe os parametros guardados na própria Layer
if "dbname" in part[0]:
dbname = part[1].replace("'", "")
elif "host" in part[0]:
host = part[1].replace("'", "")
elif "port" in part[0]:
port = int(part[1].replace("'", ""))
elif "user" in part[0]:
user = part[1].replace("'", "")
elif "password" in part[0]:
password = part[1].split("|")[0].replace("'", "")
#print dbname, host, port, user, password
# Testa se os parametros receberam os valores pretendidos, caso não, apresenta a mensagem informando..
if len(dbname) == 0 or len(host) == 0 or port == 0 or len(user) == 0 or len(password) == 0:
self.iface.messageBar().pushMessage("Erro", u'Um dos parametros não foram devidamente recebidos!', level=QgsMessageBar.CRITICAL, duration=4)
return
####################################
#### SETA VALORES DE CONEXÃO DB ####
####################################
connection = QSqlDatabase.addDatabase('QPSQL')
connection.setHostName(host)
connection.setPort(port)
connection.setUserName(user)
connection.setPassword(password)
connection.setDatabaseName(dbname)
if not connection.isOpen(): # Testa se a conexão esta recebendo os parametros adequadamente.
if not connection.open():
print 'Error connecting to database!'
self.iface.messageBar().pushMessage("Erro", u'Error connecting to database!', level=QgsMessageBar.CRITICAL, duration=4)
print connection.lastError().text()
return
####################################
###### CRIAÇÃO DE MEMORY LAYER #####
####################################
layerCrs = layer.crs().authid() # Passa o formato (epsg: numeros)
flagsLayerName = layer.name() + "_flags"
flagsLayerExists = False
for l in QgsMapLayerRegistry.instance().mapLayers().values(): # Recebe todas as camadas que estão abertas
if l.name() == flagsLayerName: # ao encontrar o nome pretendido..
self.flagsLayer = l # flagslayer vai receber o nome..
self.flagsLayerProvider = l.dataProvider()
flagsLayerExists = True # se encontrado os parametros buscados, recebe True.
break
if flagsLayerExists == False: # se não encontrado os parametros buscados, recebe False.
tempString = "Point?crs="
tempString += str(layerCrs)
self.flagsLayer = QgsVectorLayer(tempString, flagsLayerName, "memory")
self.flagsLayerProvider = self.flagsLayer.dataProvider()
self.flagsLayerProvider.addAttributes([QgsField("id", QVariant.Int), QgsField("motivo", QVariant.String)])
self.flagsLayer.updateFields()
self.flagsLayer.startEditing()
ids = [feat.id() for feat in self.flagsLayer.getFeatures()]
self.flagsLayer.deleteFeatures(ids)
self.flagsLayer.commitChanges()
lista_fid = [] # Iniciando lista
for f in layer.getFeatures():
lista_fid.append(str(f.id())) # Guarda na lista. A lista de Feature ids passa tipo "int", foi convertido e guardado como "str".
source = layer.source().split(" ")
self.tableName = "" # Inicia vazio
layerExistsInDB = False
for i in source:
if "table=" in i or "layername=" in i: # Se encontrar os atributos pretendidos dentre todos do for
self.tableName = source[source.index(i)].split(".")[1] # Faz split em ponto e pega a segunda parte.
self.tableName = self.tableName.replace('"', '')
layerExistsInDB = True
break
if layerExistsInDB == False:
self.iface.messageBar().pushMessage("Erro", u"Provedor da camada corrente não provem do banco de dados!", level=QgsMessageBar.CRITICAL, duration=4)
return
# Busca através do SQL
query_string = '''select distinct (reason(ST_IsValidDetail(f."{2}",0))) AS motivo, '''
query_string += '''ST_AsText(ST_Multi(ST_SetSrid(location(ST_IsValidDetail(f."{2}",0)), ST_Srid(f.{2})))) as local from '''
query_string += '''(select "{3}", "{2}" from only "{0}"."{1}" where ST_IsValid("{2}") = 'f' and {3} in ({4})) as f'''
query_string = query_string.format(self.tableSchema, self.tableName, self.geometryColumn, self.keyColumn, ",".join(lista_fid))
query = QSqlQuery(query_string)
self.flagsLayer.startEditing()
flagCount = 0 # iniciando contador que será referência para os IDs da camada de memória.
listaFeatures = []
while query.next():
motivo = query.value(0)
local = query.value(1)
flagId = flagCount
flagFeat = QgsFeature()
flagGeom = QgsGeometry.fromWkt(local) # passa o local onde foi localizado o erro.
flagFeat.setGeometry(flagGeom)
flagFeat.initAttributes(2)
flagFeat.setAttribute(0,flagId) # insere o id definido para a coluna 0 da layer de memória.
flagFeat.setAttribute(1, motivo) # insere o motivo/razão pré-definida para a coluna 1 da layer de memória.
listaFeatures.append(flagFeat)
flagCount += 1 # incrementando o contador a cada iteração
self.flagsLayerProvider.addFeatures(listaFeatures)
self.flagsLayer.commitChanges() # Aplica as alterações à camada.
QgsMapLayerRegistry.instance().addMapLayer(self.flagsLayer) # Adicione a camada no mapa
##################################
##### TROCA MARCADOR DA LAYER ####
##################################
# # AQUI PRETENDO PERSONALIZAR O MARCADOR DA MEMORY LAYER, POREM A PRINCIPIO SÓ ESTA ALTERANDO A LAYER ORIGINAL.
# for lay in QgsMapLayerRegistry.instance().mapLayers().values():
# if lay == flagsLayerName and not layer.name():
# # Estilo base.
# line = QgsLineSymbolV2()
# # Crie uma linha de marcadores.
# marker_line = QgsMarkerLineSymbolLayerV2()
# marker_line.setInterval(10)
# # Configure o marcador.
# simple_marker = QgsSimpleMarkerSymbolLayerV2()
# simple_marker.setShape(QgsSimpleMarkerSymbolLayerBase.HalfSquare) # Formato
# simple_marker.setSize(3)
# simple_marker.setAngle(180)
# simple_marker.setColor(QColor('red')) # cor
# simple_marker.setOutlineColor(QColor('red')) # cor
# # O marcador tem sua própria camada de símbolo.
# marker = QgsMarkerSymbolV2()
# marker.changeSymbolLayer(0, simple_marker)
# # Adicione a camada à camada do marcador.
# marker_line.setSubSymbol(marker)
# # Finalmente, substitua a camada de símbolo no estilo base.
# line.changeSymbolLayer(0, marker_line)
# # Adicione o estilo à camada de linha.
# renderer = QgsSingleSymbolRendererV2(line)
# layer.setRendererV2(renderer)
if flagCount == 0:
QgsMapLayerRegistry.instance().removeMapLayer(self.flagsLayer.id())
self.iface.messageBar().pushMessage("Aviso", u"Não foi encontrado Flags em \"" + layer.name() + "\" !", level=QgsMessageBar.CRITICAL, duration=4)
return
if len(query.lastError().text()) == 1:
self.iface.messageBar().pushMessage("Aviso", "foram geradas " + str(flagCount) + " flags para a camada \"" + layer.name() + "\" !", level=QgsMessageBar.INFO, duration=4)
else:
self.iface.messageBar().pushMessage("Erro", u"a geração de flags falhou!", level=QgsMessageBar.CRITICAL, duration=4)
print query.lastError().text()
def legend_test(self):
self.atlas_map.setAtlasDriven(True)
self.atlas_map.setAtlasScalingMode(QgsLayoutItemMap.Auto)
self.atlas_map.setAtlasMargin(0.10)
# add a point layer
ptLayer = QgsVectorLayer("Point?crs=epsg:4326&field=attr:int(1)&field=label:string(20)", "points", "memory")
pr = ptLayer.dataProvider()
f1 = QgsFeature(1)
f1.initAttributes(2)
f1.setAttribute(0, 1)
f1.setAttribute(1, "Test label 1")
f1.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-0.638, 48.954)))
f2 = QgsFeature(2)
f2.initAttributes(2)
f2.setAttribute(0, 2)
f2.setAttribute(1, "Test label 2")
f2.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(-1.682, 48.550)))
pr.addFeatures([f1, f2])
# categorized symbology
r = QgsCategorizedSymbolRenderer("attr", [QgsRendererCategory(1, QgsMarkerSymbol.createSimple({"color": "255,0,0", 'outline_color': 'black'}), "red"),
QgsRendererCategory(2, QgsMarkerSymbol.createSimple({"color": "0,0,255", 'outline_color': 'black'}), "blue")])
ptLayer.setRenderer(r)
QgsProject.instance().addMapLayer(ptLayer)
# add the point layer to the map settings
layers = self.layers
layers = [ptLayer] + layers
self.atlas_map.setLayers(layers)
self.overview.setLayers(layers)
# add a legend
legend = QgsLayoutItemLegend(self.layout)
legend.setTitle("Legend")
legend.attemptMove(QgsLayoutPoint(200, 100))
# sets the legend filter parameter
legend.setLinkedMap(self.atlas_map)
legend.setLegendFilterOutAtlas(True)
self.layout.addLayoutItem(legend)
self.atlas.beginRender()
self.atlas.seekTo(0)
self.mLabel1.adjustSizeToText()
checker = QgsLayoutChecker('atlas_legend', self.layout)
myTestResult, myMessage = checker.testLayout()
self.report += checker.report()
self.assertTrue(myTestResult, myMessage)
self.atlas.endRender()
# restore state
self.atlas_map.setLayers([layers[1]])
self.layout.removeLayoutItem(legend)
QgsProject.instance().removeMapLayer(ptLayer.id())
