def testSettingFeature(self):
""" test that feature is set when item moves """
a = QgsTextAnnotation()
a.setFrameSizeMm(QSizeF(300 / 3.7795275, 200 / 3.7795275))
a.setFrameOffsetFromReferencePointMm(QPointF(40 / 3.7795275, 50 / 3.7795275))
a.setHasFixedMapPosition(True)
a.setMapPosition(QgsPointXY(12, 34))
a.setMapPositionCrs(QgsCoordinateReferenceSystem(4326))
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
canvas.setExtent(QgsRectangle(10, 30, 20, 35))
i = QgsMapCanvasAnnotationItem(a, canvas) # NOQA
layer = QgsVectorLayer("Point?crs=EPSG:4326&field=station:string&field=suburb:string",
'test', "memory")
canvas.setLayers([layer])
f = QgsFeature(layer.fields())
f.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(14, 31)))
f.setValid(True)
f.setAttributes(['hurstbridge', 'somewhere'])
self.assertTrue(layer.dataProvider().addFeatures([f]))
a.setMapLayer(layer)
self.assertFalse(a.associatedFeature().isValid())
a.setMapPosition(QgsPointXY(14, 31))
self.assertTrue(a.associatedFeature().isValid())
self.assertEqual(a.associatedFeature().attributes()[0], 'hurstbridge')
a.setMapPosition(QgsPointXY(17, 31))
self.assertFalse(a.associatedFeature().isValid())
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 testGetFeaturesFidsTests(self):
fids = [f.id() for f in self.provider.getFeatures()]
self.assertEqual(len(fids), 5)
request = QgsFeatureRequest().setFilterFids([fids[0], fids[2]])
result = set([f.id() for f in self.provider.getFeatures(request)])
all_valid = all(f.isValid() for f in self.provider.getFeatures(request))
expected = set([fids[0], fids[2]])
assert result == expected, "Expected {} and got {} when testing for feature IDs filter".format(expected, result)
self.assertTrue(all_valid)
result = set(
[f.id() for f in self.provider.getFeatures(QgsFeatureRequest().setFilterFids([fids[1], fids[3], fids[4]]))]
)
expected = set([fids[1], fids[3], fids[4]])
assert result == expected, "Expected {} and got {} when testing for feature IDs filter".format(expected, result)
# providers should ignore non-existant fids
result = set(
[
f.id()
for f in self.provider.getFeatures(
QgsFeatureRequest().setFilterFids([-101, fids[1], -102, fids[3], -103, fids[4], -104])
)
]
)
expected = set([fids[1], fids[3], fids[4]])
assert result == expected, "Expected {} and got {} when testing for feature IDs filter".format(expected, result)
result = set([f.id() for f in self.provider.getFeatures(QgsFeatureRequest().setFilterFids([]))])
expected = set([])
assert result == expected, "Expected {} and got {} when testing for feature IDs filter".format(expected, result)
# Rewind mid-way
request = QgsFeatureRequest().setFilterFids([fids[1], fids[3], fids[4]])
feature_it = self.provider.getFeatures(request)
feature = QgsFeature()
feature.setValid(True)
self.assertTrue(feature_it.nextFeature(feature))
self.assertIn(feature.id(), [fids[1], fids[3], fids[4]])
first_feature = feature
self.assertTrue(feature.isValid())
# rewind
self.assertTrue(feature_it.rewind())
self.assertTrue(feature_it.nextFeature(feature))
self.assertEqual(feature.id(), first_feature.id())
self.assertTrue(feature.isValid())
# grab all features
self.assertTrue(feature_it.nextFeature(feature))
self.assertTrue(feature_it.nextFeature(feature))
# none left
self.assertFalse(feature_it.nextFeature(feature))
self.assertFalse(feature.isValid())
def testGetFeaturesFidsTests(self):
fids = [f.id() for f in self.source.getFeatures()]
self.assertEqual(len(fids), 5)
# empty list = no features
request = QgsFeatureRequest().setFilterFids([])
result = set([f.id() for f in self.source.getFeatures(request)])
self.assertFalse(result)
request = QgsFeatureRequest().setFilterFids([fids[0], fids[2]])
result = set([f.id() for f in self.source.getFeatures(request)])
all_valid = (all(f.isValid() for f in self.source.getFeatures(request)))
expected = set([fids[0], fids[2]])
assert result == expected, 'Expected {} and got {} when testing for feature IDs filter'.format(expected, result)
self.assertTrue(all_valid)
# test that results match QgsFeatureRequest.acceptFeature
for f in self.source.getFeatures():
self.assertEqual(request.acceptFeature(f), f.id() in expected)
result = set([f.id() for f in self.source.getFeatures(QgsFeatureRequest().setFilterFids([fids[1], fids[3], fids[4]]))])
expected = set([fids[1], fids[3], fids[4]])
assert result == expected, 'Expected {} and got {} when testing for feature IDs filter'.format(expected, result)
#sources should ignore non-existent fids
result = set([f.id() for f in self.source.getFeatures(QgsFeatureRequest().setFilterFids([-101, fids[1], -102, fids[3], -103, fids[4], -104]))])
expected = set([fids[1], fids[3], fids[4]])
assert result == expected, 'Expected {} and got {} when testing for feature IDs filter'.format(expected, result)
result = set([f.id() for f in self.source.getFeatures(QgsFeatureRequest().setFilterFids([]))])
expected = set([])
assert result == expected, 'Expected {} and got {} when testing for feature IDs filter'.format(expected, result)
# Rewind mid-way
request = QgsFeatureRequest().setFilterFids([fids[1], fids[3], fids[4]])
feature_it = self.source.getFeatures(request)
feature = QgsFeature()
feature.setValid(True)
self.assertTrue(feature_it.nextFeature(feature))
self.assertIn(feature.id(), [fids[1], fids[3], fids[4]])
first_feature = feature
self.assertTrue(feature.isValid())
# rewind
self.assertTrue(feature_it.rewind())
self.assertTrue(feature_it.nextFeature(feature))
self.assertEqual(feature.id(), first_feature.id())
self.assertTrue(feature.isValid())
# grab all features
self.assertTrue(feature_it.nextFeature(feature))
self.assertTrue(feature_it.nextFeature(feature))
# none left
self.assertFalse(feature_it.nextFeature(feature))
self.assertFalse(feature.isValid())
def test_Validity(self):
f = QgsFeature()
self.assertFalse(f.isValid())
f.setGeometry(QgsGeometry())
self.assertTrue(f.isValid())
f.setValid(False)
self.assertFalse(f.isValid())
fields = QgsFields()
field1 = QgsField('my_field')
fields.append(field1)
field2 = QgsField('my_field2')
fields.append(field2)
f.setFields(fields)
f.setAttribute(0, 0)
self.assertTrue(f.isValid())
f.setValid(False)
self.assertFalse(f.isValid())
f.setId(27)
self.assertTrue(f.isValid())
def testGetFeaturesFidTests(self):
fids = [f.id() for f in self.provider.getFeatures()]
assert len(fids) == 5, 'Expected 5 features, got {} instead'.format(len(fids))
for id in fids:
features = [f for f in self.provider.getFeatures(QgsFeatureRequest().setFilterFid(id))]
self.assertEqual(len(features), 1)
feature = features[0]
self.assertTrue(feature.isValid())
result = [feature.id()]
expected = [id]
assert result == expected, 'Expected {} and got {} when testing for feature ID filter'.format(expected, result)
# bad features
it = self.provider.getFeatures(QgsFeatureRequest().setFilterFid(-99999999))
feature = QgsFeature(5)
feature.setValid(False)
self.assertFalse(it.nextFeature(feature))
self.assertFalse(feature.isValid())
def testHtmlAnnotationWithFeature(self):
""" test rendering a html annotation with a feature"""
layer = QgsVectorLayer("Point?crs=EPSG:3111&field=station:string&field=suburb:string",
'test', "memory")
a = QgsHtmlAnnotation()
a.setFrameSize(QSizeF(400, 250))
a.setFrameOffsetFromReferencePoint(QPointF(70, 90))
a.setMapLayer(layer)
html = TEST_DATA_DIR + "/test_html_feature.html"
a.setSourceFile(html)
im = self.renderAnnotation(a, QPointF(20, 30))
self.assertTrue(self.imageCheck('html_nofeature', 'html_nofeature', im))
f = QgsFeature(layer.fields())
f.setValid(True)
f.setAttributes(['hurstbridge', 'somewhere'])
a.setAssociatedFeature(f)
im = self.renderAnnotation(a, QPointF(20, 30))
self.assertTrue(self.imageCheck('html_feature', 'html_feature', im))
def testSettingFeature(self):
""" test that feature is set when item moves """
a = QgsTextAnnotation()
a.setFrameSize(QSizeF(300, 200))
a.setFrameOffsetFromReferencePoint(QPointF(40, 50))
a.setHasFixedMapPosition(True)
a.setMapPosition(QgsPointXY(12, 34))
a.setMapPositionCrs(QgsCoordinateReferenceSystem(4326))
canvas = QgsMapCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
canvas.setExtent(QgsRectangle(10, 30, 20, 35))
i = QgsMapCanvasAnnotationItem(a, canvas) # NOQA
layer = QgsVectorLayer(
"Point?crs=EPSG:4326&field=station:string&field=suburb:string",
'test', "memory")
canvas.setLayers([layer])
f = QgsFeature(layer.fields())
f.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(14, 31)))
f.setValid(True)
f.setAttributes(['hurstbridge', 'somewhere'])
self.assertTrue(layer.dataProvider().addFeatures([f]))
a.setMapLayer(layer)
self.assertFalse(a.associatedFeature().isValid())
a.setMapPosition(QgsPointXY(14, 31))
self.assertTrue(a.associatedFeature().isValid())
self.assertEqual(a.associatedFeature().attributes()[0], 'hurstbridge')
a.setMapPosition(QgsPointXY(17, 31))
self.assertFalse(a.associatedFeature().isValid())
def testHtmlAnnotationWithFeature(self):
""" test rendering a html annotation with a feature"""
layer = QgsVectorLayer(
"Point?crs=EPSG:3111&field=station:string&field=suburb:string",
'test', "memory")
a = QgsHtmlAnnotation()
a.fillSymbol().symbolLayer(0).setStrokeColor(QColor(0, 0, 0))
a.markerSymbol().symbolLayer(0).setStrokeColor(QColor(0, 0, 0))
a.setFrameSizeMm(QSizeF(400 / 3.7795275, 250 / 3.7795275))
a.setFrameOffsetFromReferencePointMm(
QPointF(70 / 3.7795275, 90 / 3.7795275))
a.setMapLayer(layer)
html = TEST_DATA_DIR + "/test_html_feature.html"
a.setSourceFile(html)
im = self.renderAnnotation(a, QPointF(20, 30))
self.assertTrue(self.imageCheck('html_nofeature', 'html_nofeature',
im))
f = QgsFeature(layer.fields())
f.setValid(True)
f.setAttributes(['hurstbridge', 'somewhere'])
a.setAssociatedFeature(f)
im = self.renderAnnotation(a, QPointF(20, 30))
self.assertTrue(self.imageCheck('html_feature', 'html_feature', im))
def testGetFeaturesFidTests(self):
fids = [f.id() for f in self.source.getFeatures()]
assert len(fids) == 5, 'Expected 5 features, got {} instead'.format(len(fids))
for id in fids:
features = [f for f in self.source.getFeatures(QgsFeatureRequest().setFilterFid(id))]
self.assertEqual(len(features), 1)
feature = features[0]
self.assertTrue(feature.isValid())
result = [feature.id()]
expected = [id]
assert result == expected, 'Expected {} and got {} when testing for feature ID filter'.format(expected, result)
# test that results match QgsFeatureRequest.acceptFeature
request = QgsFeatureRequest().setFilterFid(id)
for f in self.source.getFeatures():
self.assertEqual(request.acceptFeature(f), f.id() == id)
# bad features
it = self.source.getFeatures(QgsFeatureRequest().setFilterFid(-99999999))
feature = QgsFeature(5)
feature.setValid(False)
self.assertFalse(it.nextFeature(feature))
self.assertFalse(feature.isValid())
def testGetFeaturesFidsTests(self):
fids = [f.id() for f in self.source.getFeatures()]
self.assertEqual(len(fids), 5)
request = QgsFeatureRequest().setFilterFids([fids[0], fids[2]])
result = set([f.id() for f in self.source.getFeatures(request)])
all_valid = (all(f.isValid()
for f in self.source.getFeatures(request)))
expected = set([fids[0], fids[2]])
assert result == expected, 'Expected {} and got {} when testing for feature IDs filter'.format(
expected, result)
self.assertTrue(all_valid)
# test that results match QgsFeatureRequest.acceptFeature
for f in self.source.getFeatures():
self.assertEqual(request.acceptFeature(f), f.id() in expected)
result = set([
f.id() for f in self.source.getFeatures(
QgsFeatureRequest().setFilterFids([fids[1], fids[3], fids[4]]))
])
expected = set([fids[1], fids[3], fids[4]])
assert result == expected, 'Expected {} and got {} when testing for feature IDs filter'.format(
expected, result)
#sources should ignore non-existent fids
result = set([
f.id()
for f in self.source.getFeatures(QgsFeatureRequest().setFilterFids(
[-101, fids[1], -102, fids[3], -103, fids[4], -104]))
])
expected = set([fids[1], fids[3], fids[4]])
assert result == expected, 'Expected {} and got {} when testing for feature IDs filter'.format(
expected, result)
result = set([
f.id() for f in self.source.getFeatures(
QgsFeatureRequest().setFilterFids([]))
])
expected = set([])
assert result == expected, 'Expected {} and got {} when testing for feature IDs filter'.format(
expected, result)
# Rewind mid-way
request = QgsFeatureRequest().setFilterFids(
[fids[1], fids[3], fids[4]])
feature_it = self.source.getFeatures(request)
feature = QgsFeature()
feature.setValid(True)
self.assertTrue(feature_it.nextFeature(feature))
self.assertIn(feature.id(), [fids[1], fids[3], fids[4]])
first_feature = feature
self.assertTrue(feature.isValid())
# rewind
self.assertTrue(feature_it.rewind())
self.assertTrue(feature_it.nextFeature(feature))
self.assertEqual(feature.id(), first_feature.id())
self.assertTrue(feature.isValid())
# grab all features
self.assertTrue(feature_it.nextFeature(feature))
self.assertTrue(feature_it.nextFeature(feature))
# none left
self.assertFalse(feature_it.nextFeature(feature))
self.assertFalse(feature.isValid())
class SpatialPairTestCase(unittest.TestCase):
"""
A SpatialPair is considered to be a binding between a feature
and a descriptor in the form of a data provider. The data
provider describes which columns and data attributes are available
whereas the feature describes how it is presented on a map canvas
"""
def setUp(self):
"""
Creates a mock layer returning a mock provider
"""
self.foo_layer = MockFooLayer()
self.feature = QgsFeature()
self.feature.setGeometry(QgsGeometry.fromPoint(QgsPoint(0, 0)))
self.feature.setValid(True)
def test_fail_no_dataprovider_no_feature(self):
"""
Creation of a spatial pair should fail when the given spatial pair
does not get the proper objects. The test asserts a number of
trivial faults to ensure the test works as expected.
Assertion 1: Tests with None objects
Assertion 2: Tests with integers
Assertion 3: Tests with objects reversed
"""
self.assertRaises(InvalidSpatialPairException, SpatialPair, None, None)
self.assertRaises(InvalidSpatialPairException, SpatialPair, 1, 1)
self.assertRaises(InvalidSpatialPairException, SpatialPair, self.feature, self.foo_layer)
def test_fail_no_feature(self):
"""
Creation of a spatial pair should fail when the given spatial pair
does not get a feature
"""
self.assertRaises(InvalidSpatialPairException, SpatialPair, self.foo_layer, None)
def test_fail_no_data_provider(self):
"""
Creation of a spatial pair should fail when the given spatial pair
does not get a data provider
"""
self.assertRaises(InvalidSpatialPairException, SpatialPair, None, self.feature)
def test_fail_invalid_feature(self):
"""
Creation of a spatial pair should fail when the given spatial pair
does not get a valid feature
"""
self.assertRaises(InvalidSpatialPairException, SpatialPair, self.foo_layer, QgsFeature())
def test_get_layer(self):
"""
A valid spatial pair should return the given layer properly using the
method `layer()'
"""
pair = SpatialPair(self.foo_layer, self.feature)
self.assertEquals(pair.layer(), self.foo_layer)
def test_get_data_provider(self):
"""
A valid spatial pair should return the given data provider properly
by both methods `data_provider' and `dataProvider'. The latter is
implemented for naming conventions of Qt.
"""
pair = SpatialPair(self.foo_layer, self.feature)
self.assertEquals(pair.data_provider(), self.foo_layer.dataProvider())
self.assertEquals(pair.dataProvider(), self.foo_layer.dataProvider())
def test_get_feature(self):
"""
A valid spatial pair should return the given feature properly using
the `feature' method.
"""
pair = SpatialPair(self.foo_layer, self.feature)
self.assertEquals(pair.feature(), self.feature)
class AttributesDock(QgsDockWidget):
layerChanged = pyqtSignal(QgsMapLayer)
currentValueChanged = pyqtSignal(str, QVariant)
def __init__(self, iface):
QgsDockWidget.__init__(
self,
QCoreApplication.translate('AttributesDock', 'Quick Attribution'))
self.iface = iface
self.widget = QWidget()
self.widget.setLayout(QGridLayout())
self.widget.setContentsMargins(0, 0, 0, 0)
self.layerComboBox = QgsMapLayerComboBox()
self.layerComboBox.layerChanged.connect(self.setLayer)
self.layerComboBox.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.layerTitleLabel = QLabel()
self.widget.layout().addWidget(self.layerTitleLabel, 0, 0, 1, 1)
self.widget.layout().addWidget(self.layerComboBox, 0, 1, 1, 1)
self.formWidget = QWidget()
self.formWidget.setLayout(QGridLayout())
self.formWidget.setContentsMargins(0, 0, 0, 0)
self.widget.layout().addWidget(self.formWidget, 1, 0, 1, 2)
self.setWidget(self.widget)
self.attributeForm = None
self.layer = None
self.feature = None
self.layerComboBox.setFilters(QgsMapLayerProxyModel.WritableLayer
| QgsMapLayerProxyModel.VectorLayer)
QgsProject.instance().readProject.connect(self.onProjectRead)
def setLayer(self, layer):
if layer == self.layer:
return
if self.layer:
try:
self.layer.destroyed.disconnect(self.onLayerRemoved)
except TypeError:
# Do not care if it is not connected
pass
self.layer = layer
if self.layer:
self.layer.destroyed.connect(self.onLayerRemoved)
self.layerComboBox.setLayer(layer)
if self.attributeForm:
try:
self.attributeForm.deleteLater()
except RuntimeError:
# Sometimes the form has already been deleted, that's ok for us
pass
if self.layer is not None:
context = QgsAttributeEditorContext()
context.setVectorLayerTools(self.iface.vectorLayerTools())
context.setFormMode(QgsAttributeEditorContext.StandaloneDialog)
self.attributeForm = QgsAttributeForm(self.layer, QgsFeature(),
context)
self.attributeForm.hideButtonBox()
try:
self.layer.updatedFields.disconnect(
self.attributeForm.onUpdatedFields)
except TypeError:
pass
fields = self.layer.fields()
self.feature = QgsFeature(fields)
for idx in range(self.layer.fields().count()):
self.feature.setAttribute(idx, self.layer.defaultValue(idx))
self.feature.setValid(True)
self.attributeForm.setFeature(self.feature)
self.attributeForm.widgetValueChanged.connect(
self.onAttributeChanged)
self.formWidget.layout().addWidget(self.attributeForm)
self.layerChanged.emit(self.layer)
def onLayerRemoved(self):
self.setLayer(None)
def onAttributeChanged(self, attributeName, value, changed):
idx = self.layer.fields().indexOf(attributeName)
if value != 'NULL':
defaultValue = QgsExpression.quotedValue(value)
else:
defaultValue = 'NULL'
self.layer.blockSignals(True)
self.layer.setDefaultValueDefinition(idx,
QgsDefaultValue(defaultValue))
self.layer.blockSignals(False)
self.currentValueChanged.emit(attributeName, value)
def onProjectRead(self, doc):
title, isDefined = QgsProject.instance().readEntry(
'quick_attribution', 'layercbxtitle')
if isDefined:
self.layerTitleLabel.setText(title)
else:
self.layerTitleLabel.setText(self.tr('Layer'))
