def testIndex(self):
idx = QgsSpatialIndex()
fid = 0
for y in range(5, 15, 5):
for x in range(5, 25, 5):
ft = QgsFeature()
ft.setFeatureId(fid)
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(x, y)))
idx.insertFeature(ft)
fid += 1
# intersection test
rect = QgsRectangle(7.0, 3.0, 17.0, 13.0)
fids = idx.intersects(rect)
myExpectedValue = 4
myValue = len(fids)
myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myValue)
self.assertEqual(myValue, myExpectedValue, myMessage)
fids.sort()
myMessage = ('Expected: %s\nGot: %s\n' %
([1, 2, 5, 6], fids))
assert fids == [1, 2, 5, 6], myMessage
# nearest neighbor test
fids = idx.nearestNeighbor(QgsPoint(8.75, 6.25), 3)
myExpectedValue = 0
myValue = len(fids)
myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myValue)
fids.sort()
myMessage = ('Expected: %s\nGot: %s\n' %
([0, 1, 5], fids))
assert fids == [0, 1, 5], myMessage
def to_shp(path, any_features_list, layer_fields, crs, name, encoding, geom_type):
if path is None:
if geom_type == 0:
network = QgsVectorLayer('Point?crs=' + crs.toWkt(), name, "memory")
else:
network = QgsVectorLayer('LineString?crs=' + crs.toWkt(), name, "memory")
else:
fields = QgsFields()
for field in layer_fields:
fields.append(field)
file_writer = QgsVectorFileWriter(path, encoding, fields, geom_type, crs, "ESRI Shapefile")
if file_writer.hasError() != QgsVectorFileWriter.NoError:
print "Error when creating shapefile: ", file_writer.errorMessage()
del file_writer
network = QgsVectorLayer(path, name, "ogr")
pr = network.dataProvider()
if path is None:
pr.addAttributes(layer_fields)
new_features = []
for i in any_features_list:
new_feat = QgsFeature()
new_feat.setFeatureId(i[0])
new_feat.setAttributes([attr[0] for attr in i[1]])
new_feat.setGeometry(QgsGeometry(QgsGeometry.fromWkt(str(i[2]))))
#QgsGeometry()
new_features.append(new_feat)
network.startEditing()
pr.addFeatures(new_features)
network.commitChanges()
return network
def testIndex(self):
idx = QgsSpatialIndex()
fid = 0
for y in range(5, 15, 5):
for x in range(5, 25, 5):
ft = QgsFeature()
ft.setFeatureId(fid)
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(x, y)))
idx.insertFeature(ft)
fid += 1
# intersection test
rect = QgsRectangle(7.0, 3.0, 17.0, 13.0)
fids = idx.intersects(rect)
myExpectedValue = 4
myValue = len(fids)
myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myValue)
self.assertEqual(myValue, myExpectedValue, myMessage)
fids.sort()
myMessage = ('Expected: %s\nGot: %s\n' % ([1, 2, 5, 6], fids))
assert fids == [1, 2, 5, 6], myMessage
# nearest neighbor test
fids = idx.nearestNeighbor(QgsPoint(8.75, 6.25), 3)
myExpectedValue = 0
myValue = len(fids)
myMessage = 'Expected: %s Got: %s' % (myExpectedValue, myValue)
fids.sort()
myMessage = ('Expected: %s\nGot: %s\n' % ([0, 1, 5], fids))
assert fids == [0, 1, 5], myMessage
def to_shp(path, any_features_list, layer_fields, crs, name, encoding,
geom_type):
if path is None:
if geom_type == 0:
network = QgsVectorLayer('Point?crs=' + crs.toWkt(), name,
"memory")
else:
network = QgsVectorLayer('LineString?crs=' + crs.toWkt(), name,
"memory")
else:
fields = QgsFields()
for field in layer_fields:
fields.append(field)
file_writer = QgsVectorFileWriter(path, encoding, fields, geom_type,
crs, "ESRI Shapefile")
if file_writer.hasError() != QgsVectorFileWriter.NoError:
print "Error when creating shapefile: ", file_writer.errorMessage()
del file_writer
network = QgsVectorLayer(path, name, "ogr")
pr = network.dataProvider()
if path is None:
pr.addAttributes(layer_fields)
new_features = []
for i in any_features_list:
new_feat = QgsFeature()
new_feat.setFeatureId(i[0])
new_feat.setAttributes([attr[0] for attr in i[1]])
new_feat.setGeometry(QgsGeometry(QgsGeometry.fromWkt(str(i[2]))))
#QgsGeometry()
new_features.append(new_feat)
network.startEditing()
pr.addFeatures(new_features)
network.commitChanges()
return network
def writerecords(self, records):
"""Stages multiple records."""
if type(records) != list:
raise ValueError('list expected, got {0}'.format(type(records)))
if len(self) == 0:
nr = 0
else:
nr = next(reversed(self.ordered_dict)) + 1
for record in records:
record['id'] = nr
self.ordered_dict[nr] = record
# rtree
# self._spatial_index.insert(nr, geom)
# QGIS:
feature = QgsFeature()
feature.setFeatureId(nr)
try:
geom = shape(record['geometry'])
qgeom = QgsGeometry()
qgeom.fromWkb(geom.to_wkb())
except:
wkt = "{}({})".format(
record['geometry']['type'],
",".join(["{} {}".format(*c) for c in record['geometry']['coordinates']]))
qgeom = QgsGeometry()
qgeom.fromWkt(wkt)
feature.setGeometry(qgeom)
self._spatial_index.insertFeature(feature)
nr += 1
def test_signalConnection(self):
# remove all layers
QgsMapLayerRegistry.instance().removeAllMapLayers()
# set dependencies and add back layers
self.pointsLayer = QgsVectorLayer(
"dbname='%s' table=\"node\" (geom) sql=" % self.fn, "points",
"spatialite")
assert (self.pointsLayer.isValid())
self.linesLayer = QgsVectorLayer(
"dbname='%s' table=\"section\" (geom) sql=" % self.fn, "lines",
"spatialite")
assert (self.linesLayer.isValid())
self.pointsLayer2 = QgsVectorLayer(
"dbname='%s' table=\"node2\" (geom) sql=" % self.fn, "_points2",
"spatialite")
assert (self.pointsLayer2.isValid())
self.pointsLayer.setDependencies(
[QgsMapLayerDependency(self.linesLayer.id())])
self.pointsLayer2.setDependencies(
[QgsMapLayerDependency(self.pointsLayer.id())])
# this should update connections between layers
QgsMapLayerRegistry.instance().addMapLayers([self.pointsLayer])
QgsMapLayerRegistry.instance().addMapLayers([self.linesLayer])
QgsMapLayerRegistry.instance().addMapLayers([self.pointsLayer2])
ms = QgsMapSettings()
ms.setOutputSize(QSize(100, 100))
ms.setExtent(QgsRectangle(0, 0, 1, 1))
self.assertTrue(ms.hasValidSettings())
u = QgsSnappingUtils()
u.setMapSettings(ms)
u.setSnapToMapMode(QgsSnappingUtils.SnapAdvanced)
layers = [
QgsSnappingUtils.LayerConfig(self.pointsLayer,
QgsPointLocator.Vertex, 20,
QgsTolerance.Pixels),
QgsSnappingUtils.LayerConfig(self.pointsLayer2,
QgsPointLocator.Vertex, 20,
QgsTolerance.Pixels)
]
u.setLayers(layers)
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setFeatureId(4)
geom = QgsGeometry.fromWkt("LINESTRING(0.5 0.2,0.6 0)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the second snapped point is ok
m = u.snapToMap(QPoint(75, 100 - 0))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPoint(0.8, 0.0))
self.pointsLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
def __make_test_feature(self, x, y):
f = QgsFeature()
wkt = QgsPoint(x, y).wellKnownText()
geom = QgsGeometry.fromWkt(wkt)
f.setGeometry(geom)
f.setFeatureId(self.test_id)
self.test_id += 1
f.setValid(True)
return f
def test_signalConnection(self):
# remove all layers
QgsProject.instance().removeAllMapLayers()
# set dependencies and add back layers
self.pointsLayer = QgsVectorLayer("dbname='%s' table=\"node\" (geom) sql=" % self.fn, "points", "spatialite")
assert self.pointsLayer.isValid()
self.linesLayer = QgsVectorLayer("dbname='%s' table=\"section\" (geom) sql=" % self.fn, "lines", "spatialite")
assert self.linesLayer.isValid()
self.pointsLayer2 = QgsVectorLayer(
"dbname='%s' table=\"node2\" (geom) sql=" % self.fn, "_points2", "spatialite"
)
assert self.pointsLayer2.isValid()
self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())])
self.pointsLayer2.setDependencies([QgsMapLayerDependency(self.pointsLayer.id())])
# this should update connections between layers
QgsProject.instance().addMapLayers([self.pointsLayer])
QgsProject.instance().addMapLayers([self.linesLayer])
QgsProject.instance().addMapLayers([self.pointsLayer2])
ms = QgsMapSettings()
ms.setOutputSize(QSize(100, 100))
ms.setExtent(QgsRectangle(0, 0, 1, 1))
self.assertTrue(ms.hasValidSettings())
u = QgsSnappingUtils()
u.setMapSettings(ms)
cfg = u.config()
cfg.setEnabled(True)
cfg.setMode(QgsSnappingConfig.AdvancedConfiguration)
cfg.setIndividualLayerSettings(
self.pointsLayer,
QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels),
)
cfg.setIndividualLayerSettings(
self.pointsLayer2,
QgsSnappingConfig.IndividualLayerSettings(True, QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels),
)
u.setConfig(cfg)
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setFeatureId(4)
geom = QgsGeometry.fromWkt("LINESTRING(0.5 0.2,0.6 0)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the second snapped point is ok
m = u.snapToMap(QPoint(75, 100 - 0))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPoint(0.8, 0.0))
self.pointsLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
def to_shp(self, any_features_list, crs, name ):
network = QgsVectorLayer('LineString?crs=' + crs.toWkt(), name, "memory")
pr = network.dataProvider()
pr.addAttributes(self.layer_fields)
new_features = []
for i in any_features_list:
new_feat = QgsFeature()
new_feat.setFeatureId(i[0])
new_feat.setAttributes(i[1])
new_feat.setGeometry(QgsGeometry.fromWkt(i[2]))
new_features.append(new_feat)
network.startEditing()
pr.addFeatures(new_features)
network.commitChanges()
return network
def to_shp(self, any_features_list, crs, name):
network = QgsVectorLayer('LineString?crs=' + crs.toWkt(), name,
"memory")
pr = network.dataProvider()
pr.addAttributes(self.layer_fields)
new_features = []
for i in any_features_list:
new_feat = QgsFeature()
new_feat.setFeatureId(i[0])
new_feat.setAttributes(i[1])
new_feat.setGeometry(QgsGeometry.fromWkt(i[2]))
new_features.append(new_feat)
network.startEditing()
pr.addFeatures(new_features)
network.commitChanges()
return network
def add_feature(self,
geom,
attributes,
lyr,
parcel_ids,
parcel_ids_names=[]):
"""
Adds a QgsFeature (geometry and attributes) to the given QgsVectorLayer.
parcel_ids and parcel_ids_names are manipulated inside this method.
:param geom: The geometry for the feature (should be in the correct SRS of the layer - no checking here!
:param attributes: dictionary of hard coded attributes for the layer - must fit the data model of the layer!
:param lyr: QgsVectorLayer
:param parcel_ids: list of parcel_ids; parcel_id is appended to it after the adding of the feature to the layer
:param parcel_ids_names: list of parcel_ids and parcel names; parcel_id and parcel name
are appended to it after the adding of the feature to the layer
parcel_ids and parcel_ids_names are both used for the internal checking of already added parcels
"""
feat = QgsFeature()
feat.setFeatureId(attributes["parcel_id"])
feat.setGeometry(geom)
#
row = [
attributes["parcel_id"], attributes["name"], attributes["entity"],
attributes["crop"], attributes["startdate"], attributes["enddate"],
attributes["planting"], attributes["harvest"], attributes["area"],
attributes["apikey"], attributes["host"]
]
feat.setAttributes(row)
lyr.dataProvider().addFeatures([feat])
parcel_ids.append(attributes["parcel_id"])
parcel_ids_names.append(u"{0} - {1}".format(attributes["parcel_id"],
attributes["name"]))
def addfeaturestolayer(layer, featurecount):
for count in xrange(featurecount):
feature = QgsFeature()
feature.setFeatureId(count)
layer.dataProvider().addFeatures([feature])
return layer
def add_edges(self):
new_key_count = 0
f_count = 1
for f in self.layer.getFeatures():
self.progress.emit(3 * f_count / self.feat_count)
f_count += 1
if self.killed is True:
break
geom_type = f.geometry().wkbType()
if geom_type not in [5, 2, 1] and f.geometry().geometry().is3D():
f.geometry().geometry().dropZValue()
geom_type = f.geometry().wkbType()
if geom_type == 5:
if self.errors:
self.errors_features[f.id()] = ('multipart',
f.geometry().exportToWkt())
for multipart in f.geometry().asGeometryCollection():
new_key_count += 1
attr = f.attributes()
new_feat = QgsFeature()
new_feat.setAttributes(attr)
new_feat.setFeatureId(new_key_count)
if self.tolerance:
snapped_wkt = make_snapped_wkt(multipart.exportToWkt(),
self.tolerance)
else:
snapped_wkt = multipart.exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
new_feat.setGeometry(snapped_geom)
self.features.append(new_feat)
self.attributes[new_key_count] = attr
self.geometries[
new_key_count] = new_feat.geometryAndOwnership()
self.geometries_wkt[new_key_count] = snapped_wkt
self.geometries_vertices[new_key_count] = [
vertex for vertex in vertices_from_wkt_2(snapped_wkt)
]
# insert features to index
self.spIndex.insertFeature(new_feat)
self.ml_keys[new_key_count] = f.id()
elif geom_type == 1:
if self.errors:
self.errors_features[f.id()] = (
'point', QgsGeometry().exportToWkt())
elif not f.geometry().isGeosValid():
if self.errors:
self.errors_features[f.id()] = (
'invalid', QgsGeometry().exportToWkt())
elif geom_type == 2:
attr = f.attributes()
if self.tolerance:
snapped_wkt = make_snapped_wkt(f.geometry().exportToWkt(),
self.tolerance)
else:
snapped_wkt = f.geometry().exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
f.setGeometry(snapped_geom)
new_key_count += 1
f.setFeatureId(new_key_count)
self.features.append(f)
self.attributes[f.id()] = attr
self.geometries[f.id()] = f.geometryAndOwnership()
self.geometries_wkt[f.id()] = snapped_wkt
self.geometries_vertices[f.id()] = [
vertex for vertex in vertices_from_wkt_2(snapped_wkt)
]
# insert features to index
self.spIndex.insertFeature(f)
self.ml_keys[new_key_count] = f.id()
def test_resetSnappingIndex(self):
self.pointsLayer.setDependencies([])
self.linesLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
ms = QgsMapSettings()
ms.setOutputSize(QSize(100, 100))
ms.setExtent(QgsRectangle(0, 0, 1, 1))
self.assertTrue(ms.hasValidSettings())
u = QgsSnappingUtils()
u.setMapSettings(ms)
cfg = u.config()
cfg.setMode(QgsSnappingConfig.AdvancedConfiguration)
cfg.setIndividualLayerSettings(
self.pointsLayer,
QgsSnappingConfig.IndividualLayerSettings(True,
QgsSnappingConfig.Vertex,
20, QgsTolerance.Pixels))
u.setConfig(cfg)
m = u.snapToMap(QPoint(95, 100))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPoint(1, 0))
f = QgsFeature(self.linesLayer.fields())
f.setFeatureId(1)
geom = QgsGeometry.fromWkt("LINESTRING(0 0,1 1)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
l1 = len([f for f in self.pointsLayer.getFeatures()])
self.assertEqual(l1, 4)
m = u.snapToMap(QPoint(95, 0))
# snapping not updated
self.pointsLayer.setDependencies([])
self.assertEqual(m.isValid(), False)
# set layer dependencies
self.pointsLayer.setDependencies(
[QgsMapLayerDependency(self.linesLayer.id())])
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setFeatureId(2)
geom = QgsGeometry.fromWkt("LINESTRING(0 0,0.5 0.5)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the snapped point is ok
m = u.snapToMap(QPoint(45, 50))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPoint(0.5, 0.5))
self.pointsLayer.setDependencies([])
# test chained layer dependencies A -> B -> C
cfg.setIndividualLayerSettings(
self.pointsLayer2,
QgsSnappingConfig.IndividualLayerSettings(True,
QgsSnappingConfig.Vertex,
20, QgsTolerance.Pixels))
u.setConfig(cfg)
self.pointsLayer.setDependencies(
[QgsMapLayerDependency(self.linesLayer.id())])
self.pointsLayer2.setDependencies(
[QgsMapLayerDependency(self.pointsLayer.id())])
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setFeatureId(3)
geom = QgsGeometry.fromWkt("LINESTRING(0 0.2,0.5 0.8)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the second snapped point is ok
m = u.snapToMap(QPoint(75, 100 - 80))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPoint(0.7, 0.8))
self.pointsLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
def addfeaturestolayer(layer, featurecount):
for count in xrange(featurecount):
feature = QgsFeature()
feature.setFeatureId(count)
layer.dataProvider().addFeatures([feature])
return layer
def __init__(self,layer, tolerance, uid, errors):
QObject.__init__(self)
self.layer = layer
self.feat_count = self.layer.featureCount()
self.tolerance = tolerance
self.uid = uid
self.errors = errors
self.multiparts = []
self.points = []
self.invalids = []
self.features = []
self.attributes = {}
self.geometries = {}
self.geometries_wkt = {}
self.geometries_vertices = {}
# create spatial index object
self.spIndex = QgsSpatialIndex()
self.layer_fields = [QgsField(i.name(), i.type()) for i in self.layer.dataProvider().fields()]
if self.uid is not None:
self.uid_index = [index for index,field in enumerate(self.layer_fields) if field.name() == self.uid].pop()
self.fid_to_uid = {}
self.uid_to_fid = {}
new_key_count = 0
f_count = 1
for f in self.layer.getFeatures():
self.progress.emit(45 * f_count / self.feat_count)
f_count += 1
attr = f.attributes()
if f.geometry().wkbType() == 5 :
attr = f.attributes()
if self.errors and self.uid is not None:
self.multiparts.append(attr[self.uid_index])
self.uid_to_fid[attr[self.uid_index]] = f.id()
for multipart in f.geometry().asGeometryCollection():
new_key_count += 1
if self.uid is not None:
self.fid_to_uid[new_key_count] = attr[self.uid_index]
attr = f.attributes()
new_feat = QgsFeature()
new_feat.setAttributes(attr)
new_feat.setFeatureId(new_key_count)
if self.tolerance:
snapped_wkt = make_snapped_wkt(multipart.exportToWkt(), self.tolerance)
else:
snapped_wkt = multipart.exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
new_feat.setGeometry(snapped_geom)
self.features.append(new_feat)
self.attributes[new_key_count] = attr
self.geometries[new_key_count] = new_feat.geometryAndOwnership()
self.geometries_wkt[new_key_count] = snapped_wkt
self.geometries_vertices[new_key_count] = [vertex for vertex in vertices_from_wkt_2(snapped_wkt)]
# insert features to index
self.spIndex.insertFeature(new_feat)
elif f.geometry().wkbType() == 1:
if self.errors and self.uid is not None:
self.points.append(attr[self.uid_index])
elif not f.geometry().isGeosValid():
if self.errors and self.uid is not None:
self.invalids.append(attr[self.uid_index])
elif f.geometry().wkbType() == 2:
attr = f.attributes()
if self.tolerance:
snapped_wkt = make_snapped_wkt(f.geometry().exportToWkt(), self.tolerance)
else:
snapped_wkt = f.geometry().exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
f.setGeometry(snapped_geom)
new_key_count += 1
f.setFeatureId(new_key_count)
self.features.append(f)
self.attributes[f.id()] = attr
self.geometries[f.id()] = f.geometryAndOwnership()
self.geometries_wkt[f.id()] = snapped_wkt
self.geometries_vertices[f.id()] = [vertex for vertex in vertices_from_wkt_2(snapped_wkt)]
# insert features to index
self.spIndex.insertFeature(f)
if self.uid is not None:
self.fid_to_uid[f.id()] = attr[self.uid_index]
self.uid_to_fid[attr[self.uid_index]] = f.id()
def add_edges(self):
new_key_count = 0
f_count = 1
for f in self.layer.getFeatures():
self.progress.emit(3 * f_count / self.feat_count)
f_count += 1
if self.killed is True:
break
geom_type = f.geometry().wkbType()
if geom_type not in [5,2,1] and f.geometry().geometry().is3D():
f.geometry().geometry().dropZValue()
geom_type = f.geometry().wkbType()
if geom_type == 5:
if self.errors:
self.errors_features[f.id()] = ('multipart', f.geometry().exportToWkt())
for multipart in f.geometry().asGeometryCollection():
new_key_count += 1
attr = f.attributes()
new_feat = QgsFeature()
new_feat.setAttributes(attr)
new_feat.setFeatureId(new_key_count)
if self.tolerance:
snapped_wkt = make_snapped_wkt(multipart.exportToWkt(), self.tolerance)
else:
snapped_wkt = multipart.exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
new_feat.setGeometry(snapped_geom)
self.features.append(new_feat)
self.attributes[new_key_count] = attr
self.geometries[new_key_count] = new_feat.geometryAndOwnership()
self.geometries_wkt[new_key_count] = snapped_wkt
self.geometries_vertices[new_key_count] = [vertex for vertex in vertices_from_wkt_2(snapped_wkt)]
# insert features to index
self.spIndex.insertFeature(new_feat)
self.ml_keys[new_key_count] = f.id()
elif geom_type == 1:
if self.errors:
self.errors_features[f.id()] = ('point', QgsGeometry().exportToWkt())
elif not f.geometry().isGeosValid():
if self.errors:
self.errors_features[f.id()] = ('invalid', QgsGeometry().exportToWkt())
elif geom_type == 2:
attr = f.attributes()
if self.tolerance:
snapped_wkt = make_snapped_wkt(f.geometry().exportToWkt(), self.tolerance)
else:
snapped_wkt = f.geometry().exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
f.setGeometry(snapped_geom)
new_key_count += 1
f.setFeatureId(new_key_count)
self.features.append(f)
self.attributes[f.id()] = attr
self.geometries[f.id()] = f.geometryAndOwnership()
self.geometries_wkt[f.id()] = snapped_wkt
self.geometries_vertices[f.id()] = [vertex for vertex in vertices_from_wkt_2(snapped_wkt)]
# insert features to index
self.spIndex.insertFeature(f)
self.ml_keys[new_key_count] = f.id()
if __name__ == '__main__':
import sys
import random
from qgis.core import QgsApplication, QgsVectorLayer, QgsFeature
from .data_interface import FeatureData
app = QgsApplication([bytes(x, "utf8") for x in sys.argv], True)
app.initQgis()
# feature example
layer = QgsVectorLayer("None?field=y:double", "test_feature", "memory")
feature = QgsFeature()
y_values = ",".join([str(random.uniform(1., 100.)) for i in range(1000)])
feature.setAttributes([y_values])
feature.setFeatureId(1)
layer.dataProvider().addFeatures([feature])
x_values = [float(x) for x in range(1, 1001)]
layer2 = QgsVectorLayer("None?field=y:double", "test_feature", "memory")
feature = QgsFeature()
y_values2 = ",".join([str(random.uniform(1., 100.)) for i in range(1000)])
feature.setAttributes([y_values2])
feature.setFeatureId(1)
layer2.dataProvider().addFeatures([feature])
w = TimeSeriesView("Sample")
w.add_data_row(
FeatureData(layer, "y", feature_id=1, x_start=1.0, x_delta=1.0),
"test title", "m")
w.add_data_row(FeatureData(layer2, "y", x_values, 1), "test title2", "m")
def __init__(self, layer, tolerance, uid, errors):
QObject.__init__(self)
self.layer = layer
self.feat_count = self.layer.featureCount()
self.tolerance = tolerance
self.uid = uid
self.errors = errors
self.multiparts = []
self.points = []
self.invalids = []
self.features = []
self.attributes = {}
self.geometries = {}
self.geometries_wkt = {}
self.geometries_vertices = {}
# create spatial index object
self.spIndex = QgsSpatialIndex()
self.layer_fields = [
QgsField(i.name(), i.type())
for i in self.layer.dataProvider().fields()
]
if self.uid is not None:
self.uid_index = [
index for index, field in enumerate(self.layer_fields)
if field.name() == self.uid
].pop()
self.fid_to_uid = {}
self.uid_to_fid = {}
new_key_count = 0
f_count = 1
for f in self.layer.getFeatures():
self.progress.emit(45 * f_count / self.feat_count)
f_count += 1
attr = f.attributes()
if f.geometry().wkbType() == 5:
attr = f.attributes()
if self.errors and self.uid is not None:
self.multiparts.append(attr[self.uid_index])
self.uid_to_fid[attr[self.uid_index]] = f.id()
for multipart in f.geometry().asGeometryCollection():
new_key_count += 1
if self.uid is not None:
self.fid_to_uid[new_key_count] = attr[self.uid_index]
attr = f.attributes()
new_feat = QgsFeature()
new_feat.setAttributes(attr)
new_feat.setFeatureId(new_key_count)
if self.tolerance:
snapped_wkt = make_snapped_wkt(multipart.exportToWkt(),
self.tolerance)
else:
snapped_wkt = multipart.exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
new_feat.setGeometry(snapped_geom)
self.features.append(new_feat)
self.attributes[new_key_count] = attr
self.geometries[
new_key_count] = new_feat.geometryAndOwnership()
self.geometries_wkt[new_key_count] = snapped_wkt
self.geometries_vertices[new_key_count] = [
vertex for vertex in vertices_from_wkt_2(snapped_wkt)
]
# insert features to index
self.spIndex.insertFeature(new_feat)
elif f.geometry().wkbType() == 1:
if self.errors and self.uid is not None:
self.points.append(attr[self.uid_index])
elif not f.geometry().isGeosValid():
if self.errors and self.uid is not None:
self.invalids.append(attr[self.uid_index])
elif f.geometry().wkbType() == 2:
attr = f.attributes()
if self.tolerance:
snapped_wkt = make_snapped_wkt(f.geometry().exportToWkt(),
self.tolerance)
else:
snapped_wkt = f.geometry().exportToWkt()
snapped_geom = QgsGeometry.fromWkt(snapped_wkt)
f.setGeometry(snapped_geom)
new_key_count += 1
f.setFeatureId(new_key_count)
self.features.append(f)
self.attributes[f.id()] = attr
self.geometries[f.id()] = f.geometryAndOwnership()
self.geometries_wkt[f.id()] = snapped_wkt
self.geometries_vertices[f.id()] = [
vertex for vertex in vertices_from_wkt_2(snapped_wkt)
]
# insert features to index
self.spIndex.insertFeature(f)
if self.uid is not None:
self.fid_to_uid[f.id()] = attr[self.uid_index]
self.uid_to_fid[attr[self.uid_index]] = f.id()
def test_resetSnappingIndex(self):
self.pointsLayer.setDependencies([])
self.linesLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
ms = QgsMapSettings()
ms.setOutputSize(QSize(100, 100))
ms.setExtent(QgsRectangle(0, 0, 1, 1))
self.assertTrue(ms.hasValidSettings())
u = QgsSnappingUtils()
u.setMapSettings(ms)
cfg = u.config()
cfg.setMode(QgsSnappingConfig.AdvancedConfiguration)
cfg.setIndividualLayerSettings(self.pointsLayer,
QgsSnappingConfig.IndividualLayerSettings(True,
QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels))
u.setConfig(cfg)
m = u.snapToMap(QPoint(95, 100))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPoint(1, 0))
f = QgsFeature(self.linesLayer.fields())
f.setFeatureId(1)
geom = QgsGeometry.fromWkt("LINESTRING(0 0,1 1)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
l1 = len([f for f in self.pointsLayer.getFeatures()])
self.assertEqual(l1, 4)
m = u.snapToMap(QPoint(95, 0))
# snapping not updated
self.pointsLayer.setDependencies([])
self.assertEqual(m.isValid(), False)
# set layer dependencies
self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())])
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setFeatureId(2)
geom = QgsGeometry.fromWkt("LINESTRING(0 0,0.5 0.5)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the snapped point is ok
m = u.snapToMap(QPoint(45, 50))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPoint(0.5, 0.5))
self.pointsLayer.setDependencies([])
# test chained layer dependencies A -> B -> C
cfg.setIndividualLayerSettings(self.pointsLayer2,
QgsSnappingConfig.IndividualLayerSettings(True,
QgsSnappingConfig.Vertex, 20, QgsTolerance.Pixels))
u.setConfig(cfg)
self.pointsLayer.setDependencies([QgsMapLayerDependency(self.linesLayer.id())])
self.pointsLayer2.setDependencies([QgsMapLayerDependency(self.pointsLayer.id())])
# add another line
f = QgsFeature(self.linesLayer.fields())
f.setFeatureId(3)
geom = QgsGeometry.fromWkt("LINESTRING(0 0.2,0.5 0.8)")
f.setGeometry(geom)
self.linesLayer.startEditing()
self.linesLayer.addFeatures([f])
self.linesLayer.commitChanges()
# check the second snapped point is ok
m = u.snapToMap(QPoint(75, 100 - 80))
self.assertTrue(m.isValid())
self.assertTrue(m.hasVertex())
self.assertEqual(m.point(), QgsPoint(0.7, 0.8))
self.pointsLayer.setDependencies([])
self.pointsLayer2.setDependencies([])
spIndex = QgsSpatialIndex()
indices = {}
attributes_dict = {}
centroids = {}
i = 0
for f in network.getFeatures():
if f.geometry().type() == QgsWkbTypes.LineGeometry:
if not f.geometry().isMultipart():
attributes_dict[f.id()] = f.attributes()
polyline = f.geometry().asPolyline()
for idx, p in enumerate(polyline[1:]):
ml = QgsGeometry.fromPolyline([polyline[idx], p])
new_f = QgsFeature()
new_f.setGeometry(ml.centroid())
new_f.setAttributes([f.id()])
new_f.setFeatureId(i)
i += 1
spIndex.addFeature(new_f)
centroids[i] = f.id()
else:
attributes_dict[f.id()] = f.attributes()
for pl in f.geometry().asMultiPolyline():
for idx, p in enumerate(pl[1:]):
ml = QgsGeometry.fromPolyline([pl[idx], p])
new_f = QgsFeature()
new_f.setGeometry(ml.centroid())
new_f.setAttributes([f.id()])
new_f.setFeatureId(i)
spIndex.addFeature(new_f)
centroids[i] = f.id()
i += 1
