def handleFormofLayer(self):
"""Calls all important functions in the plugin.
First, if the selected layer is valid, the plugin checks whether it has
any foreign keys which reference another table. If this is the case
then those tables are loaded into the project and a ValueRelation
widget type is created in the appropriate field. Then, all other fields
have their widgets altered based on their fieldType and length. Next,
all empty groups are removed from the MapLayerRegistry. This is in case
the plugin added an empty group for the referenced tables but none were
added.
"""
selected_layer = self.iface.activeLayer()
if selected_layer:
if selected_layer.dataProvider().name() != 'postgres':
self.iface.messageBar().pushMessage(
"Autoform",
"Please select a PostGIS layer before running the plugin.",
level=Qgis.MessageLevel(1))
return
self.identifyRelations(selected_layer)
self.alterForm(selected_layer)
self.filterEmptyGroups()
self.iface.messageBar().pushMessage(
"Autoform",
"Form widgets were successfully changed!.",
level=Qgis.MessageLevel(0))
else:
self.iface.messageBar().pushMessage(
"Autoform",
"Please select a PostGIS layer before running the plugin.",
level=Qgis.MessageLevel(2))
def testSublayerDetails(self):
ept_provider_metadata = QgsProviderRegistry.instance(
).providerMetadata('ept')
ogr_provider_metadata = QgsProviderRegistry.instance(
).providerMetadata('ogr')
if ept_provider_metadata is not None:
# test querying a uri which should be blocklisted
self.assertFalse(QgsProviderRegistry.instance().querySublayers(
unitTestDataPath() +
'/point_clouds/ept/sunshine-coast/ept-build.json'))
if ept_provider_metadata is not None and ogr_provider_metadata is not None:
# test querying a uri which is technically capable of being opened by two providers, but which one provider is preferred
# in this case we are testing a ept.json file, which should ALWAYS be treated as a ept point cloud layer even though
# the OGR provider CAN technically open json files
# when we directly query ogr provider metadata it should report sublayers for the json file...
self.assertEqual([
l.providerKey() for l in ogr_provider_metadata.querySublayers(
unitTestDataPath() +
'/point_clouds/ept/sunshine-coast/ept.json',
Qgis.SublayerQueryFlags(Qgis.SublayerQueryFlag.FastScan))
], ['ogr'])
# ...and when we query ept provider metadata directly it should also report sublayers for ept.json files...
self.assertEqual([
l.providerKey() for l in ept_provider_metadata.querySublayers(
unitTestDataPath() +
'/point_clouds/ept/sunshine-coast/ept.json',
Qgis.SublayerQueryFlags(Qgis.SublayerQueryFlag.FastScan))
], ['ept'])
# ... but when we query the provider registry itself, it should ONLY report the ept provider sublayers
self.assertEqual([
l.providerKey()
for l in QgsProviderRegistry.instance().querySublayers(
unitTestDataPath() +
'/point_clouds/ept/sunshine-coast/ept.json',
Qgis.SublayerQueryFlags(Qgis.SublayerQueryFlag.FastScan))
], ['ept'])
provider1 = TestProviderMetadata('p1')
provider2 = TestProviderMetadata('p2')
self.assertFalse(
QgsProviderRegistry.instance().querySublayers('test_uri'))
self.assertTrue(
QgsProviderRegistry.instance().registerProvider(provider1))
self.assertTrue(
QgsProviderRegistry.instance().registerProvider(provider2))
self.assertCountEqual([
p.providerKey()
for p in QgsProviderRegistry.instance().querySublayers('test_uri')
], ['p1', 'p2'])
def test_simple_format(self):
"""
Test QgsBabelSimpleImportFormat
"""
f = QgsBabelSimpleImportFormat('shapefile', 'ESRI Shapefile',
Qgis.BabelFormatCapability.Waypoints,
['shp', 'shx'])
self.assertEqual(f.name(), 'shapefile')
self.assertEqual(f.description(), 'ESRI Shapefile')
self.assertEqual(f.extensions(), ['shp', 'shx'])
self.assertEqual(
f.capabilities(),
Qgis.BabelFormatCapabilities(Qgis.BabelFormatCapability.Waypoints
| Qgis.BabelFormatCapability.Import))
f = QgsBabelSimpleImportFormat(
'shapefile', 'ESRI Shapefile',
Qgis.BabelFormatCapabilities(Qgis.BabelFormatCapability.Waypoints
| Qgis.BabelFormatCapability.Tracks))
self.assertEqual(
f.capabilities(),
Qgis.BabelFormatCapabilities(Qgis.BabelFormatCapability.Waypoints
| Qgis.BabelFormatCapability.Tracks
| Qgis.BabelFormatCapability.Import))
self.assertEqual(
f.importCommand('babel.exe', Qgis.GpsFeatureType.Waypoint,
'c:/test/test.shp', 'c:/test/test.gpx'), [
'babel.exe', '-w', '-i', 'shapefile', '-o',
'gpx', 'c:/test/test.shp', 'c:/test/test.gpx'
])
self.assertEqual(
f.importCommand('babel.exe', Qgis.GpsFeatureType.Track,
'c:/test/test.shp', 'c:/test/test.gpx'), [
'babel.exe', '-t', '-i', 'shapefile', '-o',
'gpx', 'c:/test/test.shp', 'c:/test/test.gpx'
])
self.assertEqual(
f.importCommand('babel.exe', Qgis.GpsFeatureType.Route,
'c:/test/test.shp', 'c:/test/test.gpx'), [
'babel.exe', '-r', '-i', 'shapefile', '-o',
'gpx', 'c:/test/test.shp', 'c:/test/test.gpx'
])
# with quoted paths
self.assertEqual(
f.importCommand('babel.exe', Qgis.GpsFeatureType.Route,
'c:/test/test.shp', 'c:/test/test.gpx',
Qgis.BabelCommandFlag.QuoteFilePaths),
[
'"babel.exe"', '-r', '-i', 'shapefile', '-o', 'gpx',
'"c:/test/test.shp"', '"c:/test/test.gpx"'
])
# export not supported
self.assertEqual(
f.exportCommand('babel.exe', Qgis.GpsFeatureType.Waypoint,
'c:/test/test.shp', 'c:/test/test.gpx'), [])
def settingProcessParams(self, full_filename, outPath):
self.pixel_size = self.pixelSizeDoubleSpinBox.value()
self.inter_method = self.interpolatingMethodComboBox.currentText()
self.load_result = self.addResultsCheckBox.isChecked()
self.partials_create_load = self.createAndLoadIntermCheckBox.isChecked()
_, filename = os.path.split(full_filename)
base_name, ext = os.path.splitext(filename)
start_index = 1
out_path = os.path.join(
outPath, (base_name + '_r' + str(start_index)))
if os.path.exists(out_path):
import glob
key_for_glob = os.path.join(outPath, (base_name + '_r*' ))
dirs_list = glob.glob(key_for_glob)
indexes = []
for directory in dirs_list:
try:
fn_index = int(directory[-3:])
except ValueError:
try:
fn_index = int(directory[-2:])
except ValueError:
fn_index = int(directory[-1])
indexes.append(fn_index)
max_index = max(indexes)
next_index = max_index + 1
out_path = os.path.join(outPath,
(base_name + '_r' + str(next_index)))
self.dir_fns = dir_fns.DirAndPaths(filename, out_path)
self.showMessage(u'Starting processing LiDAR data {}'.format(base_name),
Qgis.MessageLevel(0))
try:
self.process = plugin_process.Process(full_filename,
out_path,
self.pixel_size,
self.inter_method,
self.partials_create_load)
except (ValueError, OSError) as message:
self.showQMessage(str(message))
self.showMessage('LiDAR Forestry Height stopped process',
Qgis.MessageLevel(1))
return
if self.partials_create_load:
self.load_raster_layer(self.process.dirs.out_paths['dtm'])
self.load_raster_layer(self.process.dirs.out_paths['dsm'])
if self.load_result:
self.load_raster_layer(self.process.dirs.out_paths['height'])
def _log_output(self, output, lines_per_msg=None):
if lines_per_msg is None:
QgsApplication.messageLog().logMessage(output, "Interlis",
Qgis.MessageLevel(0))
else:
lines = output.splitlines()
for i in range(0, len(lines), lines_per_msg):
msg = "\n".join(lines[i:i + lines_per_msg])
QgsApplication.messageLog().logMessage(msg, "Interlis",
Qgis.MessageLevel(0))
def testGettersSetters(self):
"""
Test provider list
"""
d = QgsProviderSublayerDetails()
d.setProviderKey('key')
self.assertEqual(d.providerKey(), 'key')
d.setType(QgsMapLayerType.MeshLayer)
self.assertEqual(d.type(), QgsMapLayerType.MeshLayer)
d.setUri('some uri')
self.assertEqual(d.uri(), 'some uri')
d.setName('name')
self.assertEqual(d.name(), 'name')
d.setDescription('desc')
self.assertEqual(d.description(), 'desc')
d.setPath(['a', 'b', 'c'])
self.assertEqual(d.path(), ['a', 'b', 'c'])
self.assertEqual(d.featureCount(), Qgis.FeatureCountState.UnknownCount)
d.setFeatureCount(1000)
self.assertEqual(d.featureCount(), 1000)
self.assertEqual(d.wkbType(), QgsWkbTypes.Unknown)
d.setWkbType(QgsWkbTypes.Point)
self.assertEqual(d.wkbType(), QgsWkbTypes.Point)
d.setGeometryColumnName('geom_col')
self.assertEqual(d.geometryColumnName(), 'geom_col')
d.setLayerNumber(13)
self.assertEqual(d.layerNumber(), 13)
d.setDriverName('drv')
self.assertEqual(d.driverName(), 'drv')
d.setSkippedContainerScan(True)
self.assertTrue(d.skippedContainerScan())
d.setSkippedContainerScan(False)
self.assertFalse(d.skippedContainerScan())
d.setFlags(Qgis.SublayerFlag.SystemTable)
self.assertEqual(d.flags(),
Qgis.SublayerFlags(Qgis.SublayerFlag.SystemTable))
d.setFlags(Qgis.SublayerFlags())
self.assertEqual(d.flags(), Qgis.SublayerFlags())
def importtoqgis(self):
# QGIS OGR provider only supports one geometry column per table
# We create a VRT with separate layers for each geometry
# This is also a workaround for a random sublayer order
# in QGIS 2.18 using "file.xtf,model.imd" as dataSourceUri.
__, vrt_tmp = tempfile.mkstemp('.vrt', 'tmp_')
ogr2vrt(self.iliDs(), vrt_tmp)
dataSourceUri = vrt_tmp
# QGIS 1.8:
# subLayerVectorLayer = QgsVectorLayer(
# dataSourceUri, "interlis_sublayers", "ogr")
# subLayerProvider = subLayerVectorLayer.dataProvider()
# if not subLayerProvider:
# QMessageBox.critical(None, "Error accessing interlis sublayers",
# "A problem occured during access of the sublayers")
# return
# subLayerList = subLayerProvider.subLayers()
# subLayerDialog = SublayersDialog()
# subLayerDialog.setupSublayerList(subLayerList)
# if subLayerDialog.exec_() == QDialog.Accepted:
# for layername in subLayerDialog.subLayerNames():
# add a new ogr layer for each selected sublayer
# self._plugin.iface.addVectorLayer(
# dataSourceUri + "|layername=" + layername, layername, "ogr")
# QGIS 2: Sublayer dialog opens automatically
self._plugin.iface.addVectorLayer(dataSourceUri, "Interlis layer",
"ogr")
self.accept()
self._plugin.iface.messageBar().pushMessage("Interlis",
"Import finished",
level=Qgis.MessageLevel(0),
duration=2)
def loadModel(self):
imd = None
try:
loader = ModelLoader(self.ui.mDataLineEdit.text())
models = loader.detect_models()
model_names = map(lambda m: m.name, models)
self._log_output("Looking up models: " + ', '.join(model_names))
ili = loader.gen_lookup_ili()
qDebug(ili)
wpsreq = self._create_wps_request(ili)
url = self.ui.mIlisMetaUrlLineEdit.text()
req = QNetworkRequest(QUrl(url))
req.setHeader(QNetworkRequest.ContentTypeHeader, 'application/xml')
data = QByteArray()
data.append(wpsreq)
reply = QgsNetworkAccessManager.instance().blockingPost(req, data)
if reply.error() == QNetworkReply.NoError:
result = reply.content()
imd = self._parse_wps_response(result)
except Exception as e:
qDebug("Exception during IlisModel download")
if imd is None:
self._show_log_window()
QgsApplication.messageLog().logMessage(
"Couldn't download Ilismeta model", "Interlis",
Qgis.MessageLevel(1))
self.ui.mModelLineEdit.setText("")
else:
fh, imdfn = tempfile.mkstemp(suffix='.imd')
os.close(fh)
with codecs.open(imdfn, "w", encoding='utf-8') as file:
file.write(imd)
self.ui.mModelLineEdit.setText(imdfn)
def get_plugin_version():
with open(os.path.join(os.path.dirname(__file__), "metadata.txt"),
'r') as f:
config = configparser.ConfigParser()
config.read_file(f)
version = config["general"]["version"]
return "Plugin/" + version + " QGIS/" + Qgis.version()
def readXml(self, node):
# early read of custom properties
self.readCustomProperties(node)
# get layer type
ol_layer_type = None
ol_layer_type_name = self.customProperty(
OpenlayersLayer.LAYER_PROPERTY, "")
if ol_layer_type_name != "":
ol_layer_type = self.olLayerTypeRegistry.getByName(
ol_layer_type_name)
else:
# handle ol_layer_type idx stored in layer node
# (OL plugin <= 1.1.2)
ol_layer_type_idx = int(node.toElement().attribute(
"ol_layer_type", "-1"))
if ol_layer_type_idx != -1:
ol_layer_type = self.olLayerTypeRegistry.getById(
ol_layer_type_idx)
if ol_layer_type is not None:
self.setLayerType(ol_layer_type)
else:
# Set default layer type
self.setLayerType(
self.olLayerTypeRegistry.getByName("OpenStreetMap"))
msg = "Obsolete or unknown layer type '%s', using OpenStreetMap\
instead" % ol_layer_type_name
self.iface.messageBar().pushMessage("OpenLayers Plugin",
msg,
level=Qgis.MessageLevel(1))
QgsMessageLog.logMessage(msg, "OpenLayers Plugin",
QgsMessageLog.WARNING)
return True
def _run_tests(test_suite, package_name, with_coverage=False):
"""Core function to test a test suite."""
count = test_suite.countTestCases()
print('########')
print('%s tests has been discovered in %s' % (count, package_name))
print('Python GDAL : %s' % gdal.VersionInfo('VERSION_NUM'))
print('QGIS version : {}'.format(Qgis.version()))
print('########')
if with_coverage:
cov = coverage.Coverage(
source=['/processing_r'],
omit=['*/test/*'],
)
cov.start()
unittest.TextTestRunner(verbosity=3, stream=sys.stdout).run(test_suite)
if with_coverage:
cov.stop()
cov.save()
report = tempfile.NamedTemporaryFile(delete=False)
cov.report(file=report)
# Produce HTML reports in the `htmlcov` folder and open index.html
# cov.html_report()
report.close()
with open(report.name, 'r') as fin:
print(fin.read())
def querySublayers(self,
uri: str,
flags=Qgis.SublayerQueryFlags(),
feedback=None):
res = QgsProviderSublayerDetails()
res.setProviderKey(self.key())
return [res]
def __init__(self, table, parent=None):
TableDataModel.__init__(self, table, parent)
self.layer = None
if isinstance(table, LVectorTable):
self.layer = VLayerRegistry.instance().getLayer(table.name)
else:
self.layer = VLayerRegistry.instance().getLayer(table)
if not self.layer:
return
# populate self.resdata
self.resdata = []
for f in self.layer.getFeatures():
a = f.attributes()
# add the geometry type
if f.hasGeometry():
a.append(QgsWkbTypes.displayString(Qgis.fromOldWkbType(f.geometry().wkbType())))
else:
a.append('None')
self.resdata.append(a)
self.fetchedFrom = 0
self.fetchedCount = len(self.resdata)
def __init__(self,
key,
pluginName,
defaultValue,
description=str(),
options=Qgis.SettingsOptions()):
"""
Constructor for PyQgsSettingsEntryEnumFlag.
:param key: argument specifies the final part of the settings key.
:param pluginName: argument is inserted in the key after the section.
:param defaultValue: argument specifies the default value for the settings entry.
:param description: argument specifies a description for the settings entry.
"""
self.options = options
defaultValueStr = str()
self.__metaEnum = metaEnumFromValue(defaultValue)
if self.__metaEnum is None or not self.__metaEnum.isValid():
QgsLogger.debug(
"Invalid metaenum. Enum/Flag probably misses Q_ENUM/Q_FLAG declaration. Settings key: '{0}'"
.format(self.key()))
else:
if self.__metaEnum.isFlag():
defaultValueStr = self.__metaEnum.valueToKeys(defaultValue)
else:
defaultValueStr = self.__metaEnum.valueToKey(defaultValue)
self.__enumFlagClass = defaultValue.__class__
super().__init__(key, 'plugins/{}'.format(pluginName), defaultValueStr,
description, options)
def replaceLayer(self, group, oldLayer, newLayer):
index = 0
for child in group.children():
if QgsLayerTree.isLayer(child):
if child.layerId() == oldLayer.id():
# insert new layer
QgsProject.instance().addMapLayer(newLayer, False)
newLayerNode = group.insertLayer(index, newLayer)
newLayerNode.setVisible(child.isVisible())
# remove old layer
QgsProject.instance().removeMapLayer(oldLayer.id())
msg = "Updated layer '%s' from old OpenLayers Plugin version" % newLayer.name(
)
self.iface.messageBar().pushMessage(
"OpenLayers Plugin", msg, level=Qgis.MessageLevel(0))
QgsMessageLog.logMessage(msg, "OpenLayers Plugin",
QgsMessageLog.INFO)
# layer replaced
return True
else:
if self.replaceLayer(child, oldLayer, newLayer):
# layer replaced in child group
return True
index += 1
# layer not in this group
return False
def __init__(self, table, parent=None):
TableDataModel.__init__(self, table, parent)
self.layer = None
if isinstance(table, LVectorTable):
self.layer = VLayerRegistry.instance().getLayer(table.name)
else:
self.layer = VLayerRegistry.instance().getLayer(table)
if not self.layer:
return
# populate self.resdata
self.resdata = []
for f in self.layer.getFeatures():
a = f.attributes()
# add the geometry type
if f.hasGeometry():
a.append(
QgsWkbTypes.displayString(
Qgis.fromOldWkbType(f.geometry().wkbType())))
else:
a.append('None')
self.resdata.append(a)
self.fetchedFrom = 0
self.fetchedCount = len(self.resdata)
def querySublayers(self,
uri: str,
flags=Qgis.SublayerQueryFlags(),
feedback=None):
res = QgsProviderSublayerDetails()
res.setProviderKey(self.key())
res.setUri(uri)
res.setName(QgsProviderUtils.suggestLayerNameFromFilePath(uri))
return [res]
def runShellCmd(args):
loglines = []
loglines.append("Ili execution console output")
if isWindows():
command = ["cmd.exe", "/C ", '""' + args[0] + '"'
] + args[1:] + ['"']
else:
command = [none_typ for none_typ in args if none_typ is not None]
QgsMessageLog.logMessage(' '.join(command), level=Qgis.MessageLevel(0))
# java doesn't find quoted file on Win with: ''.join(['"%s" ' % c for c
# in command])
fused_command = ' '.join(command)
proc = subprocess.Popen(fused_command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True).stdout
for line in iter(proc.readline, ""):
loglines.append(line)
QgsMessageLog.logMessage(line, level=Qgis.MessageLevel(0))
IliUtils.consoleOutput = loglines
def check_qgis_patches():
"""Check patch level to support:
- https://github.com/qgis/QGIS/pull/41787
- https://github.com/qgis/QGIS/pull/41823
"""
str_ver = str(Qgis.versionInt())
major = int(str_ver[0])
minor = int(str_ver[1:3])
patch = int(str_ver[3:])
return (minor == 16 and patch >= 7) or (minor == 18
and patch >= 1) or minor > 18
def _calc_size(self):
realSize = self.realsize
canvaswidth = self.canvas.width()
mapunitsperpixel = abs(self.canvas.mapUnitsPerPixel())
mapunits = self.canvas.mapUnits()
prefered_units = roam.config.settings.get("prefer_units", "meters")
newunits = Qgis.fromLiteral(prefered_units, Qgis.Meters)
mapunitsperpixel *= Qgis.fromUnitToUnitFactor(mapunits, newunits)
mapunits = newunits
# Convert the real distance into pixels
barwidth = realSize / mapunitsperpixel
if barwidth < 30:
barwidth = canvaswidth / 4
while barwidth > canvaswidth / 3:
barwidth /= 3
realSize = barwidth * mapunitsperpixel
# Round
powerof10 = math.floor(math.log10(realSize))
scaler = math.pow(10.0, powerof10)
realSize = round(realSize / scaler) * scaler
barwidth = realSize / mapunitsperpixel
label, realSize = self._label_size(mapunits, realSize)
metrics = QFontMetrics(self.font)
fontwidth = metrics.width(label)
fontheight = metrics.height()
sizelabel = QLocale.system().toString(realSize)
sizelabel = "{} {}".format(sizelabel, label)
barwidth = self._adjust_bar_size(barwidth, mapunits)
barwidth = barwidth + fontwidth
return barwidth, realSize, sizelabel, (fontwidth, fontheight)
def __init__(self, maximum=100, message_title=""):
self.maximum = maximum
self.message_bar = iface.messageBar().createMessage(message_title, "")
self.progress_bar = QProgressBar()
self.progress_bar.setMaximum(maximum)
self.progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.message_bar.layout().addWidget(self.progress_bar)
if iface is not None:
iface.messageBar().pushWidget(self.message_bar,
Qgis.MessageLevel())
self.step_size = 1
self.progress = 0
def testInnerVerticesPolygon(self):
fill_symbol = QgsFillSymbol()
fill_symbol.deleteSymbolLayer(0)
fill_symbol.appendSymbolLayer(
QgsMarkerLineSymbolLayer())
fill_symbol[0].setPlacements(Qgis.MarkerLinePlacements(Qgis.MarkerLinePlacement.InnerVertices))
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
fill_symbol[0].setSubSymbol(marker_symbol)
g = QgsGeometry.fromWkt('Polygon((0 0, 10 0, 10 10, 0 10, 0 0))')
rendered_image = self.renderGeometry(fill_symbol, g)
assert self.imageCheck('markerline_inner_vertices_polygon', 'markerline_inner_vertices_polygon', rendered_image)
def testMultiplePlacements(self):
line_symbol = QgsLineSymbol()
line_symbol.deleteSymbolLayer(0)
line_symbol.appendSymbolLayer(
QgsMarkerLineSymbolLayer())
line_symbol[0].setPlacements(Qgis.MarkerLinePlacements(Qgis.MarkerLinePlacement.FirstVertex | Qgis.MarkerLinePlacement.LastVertex))
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
line_symbol[0].setSubSymbol(marker_symbol)
g = QgsGeometry.fromWkt('LineString(0 0, 10 0, 10 10, 0 10)')
rendered_image = self.renderGeometry(line_symbol, g)
assert self.imageCheck('markerline_multiple_placement', 'markerline_multiple_placement', rendered_image)
def testFirstLastVertexRespectMultipart(self):
line_symbol = QgsLineSymbol()
line_symbol.deleteSymbolLayer(0)
line_symbol.appendSymbolLayer(
QgsMarkerLineSymbolLayer())
line_symbol[0].setPlacements(Qgis.MarkerLinePlacements(Qgis.MarkerLinePlacement.FirstVertex | Qgis.MarkerLinePlacement.LastVertex))
marker = QgsSimpleMarkerSymbolLayer(QgsSimpleMarkerSymbolLayer.Triangle, 4)
marker.setColor(QColor(255, 0, 0))
marker.setStrokeStyle(Qt.NoPen)
marker_symbol = QgsMarkerSymbol()
marker_symbol.changeSymbolLayer(0, marker)
line_symbol[0].setSubSymbol(marker_symbol)
line_symbol[0].setPlaceOnEveryPart(False)
g = QgsGeometry.fromWkt('MultiLineString((0 0, 10 0, 10 10, 0 10),(3 3, 7 3, 7 7, 3 7))')
rendered_image = self.renderGeometry(line_symbol, g)
assert self.imageCheck('markerline_first_last_respect_multipart', 'markerline_first_last_respect_multipart', rendered_image)
def addLayer(self, layerType):
if layerType.hasXYZUrl():
# create XYZ layer
layer, url = self.createXYZLayer(layerType, layerType.displayName)
else:
# create OpenlayersLayer
layer = OpenlayersLayer(self.iface, self._olLayerTypeRegistry)
layer.setName(layerType.displayName)
layer.setLayerType(layerType)
if layer.isValid():
coordRefSys = layerType.coordRefSys(self.canvasCrs())
self.setMapCrs(coordRefSys)
QgsProject.instance().addMapLayer(layer)
# store xyz config into qgis settings
if layerType.hasXYZUrl():
settings = QSettings()
settings.beginGroup('qgis/connections-xyz')
settings.setValue("%s/authcfg" % (layer.name()), '')
settings.setValue("%s/password" % (layer.name()), '')
settings.setValue("%s/referer" % (layer.name()), '')
settings.setValue("%s/url" % (layer.name()), url)
settings.setValue("%s/username" % (layer.name()), '')
# specify max/min or else only a picture of the map is saved
# in settings
settings.setValue("%s/zmax" % (layer.name()), '18')
settings.setValue("%s/zmin" % (layer.name()), '0')
settings.endGroup()
# reload connections to update Browser Panel content
self.iface.reloadConnections()
self._ol_layers += [layer]
# last added layer is new reference
self.setReferenceLayer(layer)
if not layerType.hasXYZUrl():
msg = "Printing and rotating of Javascript API " \
"based layers is currently not supported!"
self.iface.messageBar().pushMessage("OpenLayers Plugin",
msg,
level=Qgis.MessageLevel(1),
duration=5)
def loadModel(self):
imd = None
try:
loader = ModelLoader(self.ui.mDataLineEdit.text())
models = loader.detect_models()
model_names = map(lambda m: m.name, models)
self._log_output("Looking up models: " + ', '.join(model_names))
ili = loader.gen_lookup_ili()
qDebug(ili)
wpsreq = self._create_wps_request(ili)
url = self.ui.mIlisMetaUrlLineEdit.text()
req = QNetworkRequest(QUrl(url))
req.setHeader(QNetworkRequest.ContentTypeHeader, 'application/xml')
reply = QgsNetworkAccessManager.instance().post(req, wpsreq)
# Wait for reply or timeout
loop = QEventLoop()
reply.finished.connect(loop.quit)
QTimer.singleShot(15000, reply.abort)
loop.exec_()
if reply.isFinished() and reply.error() == QNetworkReply.NoError:
result = reply.readAll()
imd = self._parse_wps_response(result)
except:
qDebug("Exception during IlisModel download")
if imd is None:
self._show_log_window()
QgsApplication.messageLog().logMessage(
"Couldn't download Ilismeta model", "Interlis",
Qgis.MessageLevel(1))
self.ui.mModelLineEdit.setText("")
else:
fh, imdfn = tempfile.mkstemp(suffix='.imd')
os.close(fh)
with codecs.open(imdfn, "w", encoding='utf-8') as file:
file.write(imd)
self.ui.mModelLineEdit.setText(imdfn)
def importtodb(self):
self._log_output("Import data from %s" % self.iliDs())
cfg = self._ogr_config_tmp(self.iliDs())
ogroutput = cfg.transform(
dest=self.pgDs(),
skipfailures=self.ui.cbSkipFailures.isChecked(),
debug=True)
self._remove_ogrconfig_tmp()
self._plugin.messageLogWidget().show()
self._log_output(ogroutput)
self._log_output("Import finished")
uri = self.pgUri()
layer_infos = cfg.layer_infos()
layer_names = cfg.layer_names()
# if self.ui.cbImportEnums.isChecked():
# layer_infos += cfg.enum_infos()
# layer_names += cfg.enum_names()
subLayerDialog = SublayersDialog()
subLayerDialog.setupLayerList(layer_names)
if subLayerDialog.exec_() == QDialog.Accepted:
for layer_id in subLayerDialog.layerNames():
# add a new layer for each selected row
for layer in layer_infos:
if layer['name'] == layer_id:
geom_column = layer['geom_field'] if (
'geom_field' in layer) else None
uri.setDataSource("", layer['name'], geom_column)
self._plugin.iface.addVectorLayer(
uri.uri(), layer['name'], 'postgres')
self.accept()
self._plugin.iface.messageBar().pushMessage(
"Interlis",
"Import finished",
level=Qgis.MessageLevel(0),
duration=2)
def testSelection(self):
layer = QgsVectorTileLayer(
'type=vtpk&url={}'.format(unitTestDataPath() + '/testvtpk.vtpk'),
'tiles')
self.assertTrue(layer.isValid())
self.assertFalse(layer.selectedFeatures())
spy = QSignalSpy(layer.selectionChanged)
# select by polygon
selection_geometry = QgsGeometry.fromWkt(
'Polygon ((-12225020.2316580843180418 6030602.60334861185401678, -13521860.30317855626344681 5526975.39110779482871294, -12976264.15658413991332054 4821897.29397048708051443, -12019372.45332629978656769 4884850.69550053123384714, -11650045.83101624809205532 4754746.99900492746382952, -11469579.41329662501811981 5535369.17797833122313023, -11792740.20781794004142284 6110343.57862004917114973, -12225020.2316580843180418 6030602.60334861185401678))'
)
context = QgsSelectionContext()
context.setScale(17991708)
layer.selectByGeometry(selection_geometry, context,
Qgis.SelectBehavior.SetSelection,
Qgis.SelectGeometryRelationship.Intersect)
self.assertEqual(layer.selectedFeatureCount(), 8)
self.assertCountEqual(
set(f.id() for f in layer.selectedFeatures()), {
3320043274240, 3320026497024, 2220498092032, 2224826613760,
3320043274243, 2220514869248, 3324338241541, 3324338241536
})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()), {
'Polygon ((-13222000 4970000, -13203000 5004000, -13189000 5073000, -13164000 5127000, -13145000 5205000, -13106000 5239000, -13047000 5274000, -12964000 5269000, -12910000 5195000, -12885000 5185000, -12846000 5185000, -12802000 5151000, -12758000 5093000, -12685000 5093000, -12611000 5107000, -12484000 5103000, -12484000 4970000, -13222000 4970000))',
'MultiPolygon (((-12157000 5694000, -12132000 5738000, -12093000 5782000, -12039000 5817000, -11956000 5836000, -11853000 5836000, -11795000 5792000, -11785000 5763000, -11760000 5738000, -11736000 5621000, -11716000 5587000, -11653000 5528000, -11643000 5503000, -11643000 5366000, -11653000 5337000, -11692000 5278000, -11731000 5249000, -11741000 5239000, -11839000 5205000, -11863000 5220000, -11927000 5288000, -11941000 5440000, -11951000 5450000, -12005000 5450000, -12020000 5450000, -12029000 5435000, -12054000 5435000, -12093000 5450000, -12132000 5503000, -12157000 5518000, -12166000 5543000, -12166000 5650000, -12157000 5694000),(-11995000 5680000, -12015000 5626000, -12005000 5582000, -11990000 5562000, -11927000 5547000, -11907000 5528000, -11883000 5479000, -11863000 5469000, -11829000 5469000, -11809000 5489000, -11814000 5577000, -11863000 5626000, -11912000 5704000, -11966000 5704000, -11995000 5680000)),((-11521000 5773000, -11496000 5851000, -11413000 5900000, -11389000 5890000, -11325000 5787000, -11320000 5724000, -11364000 5645000, -11418000 5640000, -11462000 5655000, -11491000 5699000, -11506000 5709000, -11521000 5773000)))',
'Polygon ((-12563000 5105000, -12470000 5102000, -12411000 4990000, -12411000 4970000, -12563000 4970000, -12563000 5105000))',
'Polygon ((-11868000 4750000, -11809000 4882000, -11702000 4956000, -11638000 4956000, -11609000 4916000, -11574000 4892000, -11452000 4882000, -11354000 4833000, -11325000 4794000, -11291000 4765000, -11212000 4638000, -11217000 4579000, -11261000 4486000, -11266000 4432000, -11281000 4393000, -11296000 4383000, -11310000 4339000, -11398000 4300000, -11501000 4305000, -11530000 4320000, -11579000 4359000, -11633000 4427000, -11687000 4466000, -11790000 4515000, -11834000 4569000, -11873000 4652000, -11868000 4750000))',
'Polygon ((-13228000 4960000, -13203000 5004000, -13194000 5049000, -12484000 5049000, -12484000 4869000, -12587000 4814000, -12631000 4765000, -12641000 4716000, -12680000 4652000, -12714000 4618000, -12837000 4589000, -12900000 4589000, -12944000 4608000, -12949000 4618000, -13027000 4623000, -13062000 4647000, -13135000 4662000, -13189000 4691000, -13228000 4779000, -13238000 4819000, -13238000 4907000, -13228000 4960000))',
'MultiLineString ((-11662000 5797000, -11633000 5704000, -11589000 5640000, -11398000 5518000, -11325000 5420000, -11276000 5127000, -11247000 5053000, -11208000 4990000, -11207000 4970000),(-11305000 5337000, -11261000 5381000, -11227000 5459000, -11178000 5518000, -11105000 5562000, -11051000 5670000, -10997000 5724000, -10953000 5812000))',
'Polygon ((-12442000 5049000, -12411000 4990000, -12411000 4956000, -12426000 4916000, -12450000 4887000, -12563000 4827000, -12563000 5049000, -12442000 5049000))',
'Point (-12714000 5220000)'
})
self.assertEqual(len(spy), 1)
self.assertNotEqual(
layer.selectedFeatures()[0].fields().lookupField('tile_zoom'), -1)
self.assertNotEqual(
layer.selectedFeatures()[0].fields().lookupField('tile_layer'), -1)
self.assertEqual(layer.selectedFeatures()[0]['tile_zoom'], 4)
self.assertCountEqual(
[f['tile_layer'] for f in layer.selectedFeatures()], [
'polys', 'polys', 'polys', 'lines', 'points', 'polys', 'polys',
'polys'
])
# select same again, should be no new signal
layer.selectByGeometry(selection_geometry, context,
Qgis.SelectBehavior.SetSelection,
Qgis.SelectGeometryRelationship.Intersect)
self.assertEqual(len(spy), 1)
# select within
layer.selectByGeometry(selection_geometry, context,
Qgis.SelectBehavior.SetSelection,
Qgis.SelectGeometryRelationship.Within)
self.assertEqual(len(spy), 2)
self.assertCountEqual(set(f.id() for f in layer.selectedFeatures()),
{2220498092032, 3320043274243})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()), {
'Point (-12714000 5220000)',
'Polygon ((-12563000 5105000, -12470000 5102000, -12411000 4990000, -12411000 4970000, -12563000 4970000, -12563000 5105000))'
})
# add to selection
selection_geometry = QgsGeometry.fromWkt(
'Polygon ((-11104449.68442200869321823 6041094.83693683333694935, -11461185.62642602622509003 5822856.37829908169806004, -11054086.96319791302084923 5419954.60850630886852741, -10793879.57020674645900726 5835447.05860510468482971, -11104449.68442200869321823 6041094.83693683333694935))'
)
layer.selectByGeometry(selection_geometry, context,
Qgis.SelectBehavior.AddToSelection,
Qgis.SelectGeometryRelationship.Intersect)
self.assertEqual(len(spy), 3)
self.assertCountEqual(
set(f.id() for f in layer.selectedFeatures()),
{2220498092032, 3320043274243, 3320043274240, 3320026497024})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()), {
'Polygon ((-12563000 5105000, -12470000 5102000, -12411000 4990000, -12411000 4970000, -12563000 4970000, -12563000 5105000))',
'MultiLineString ((-11662000 5797000, -11633000 5704000, -11589000 5640000, -11398000 5518000, -11325000 5420000, -11276000 5127000, -11247000 5053000, -11208000 4990000, -11207000 4970000),(-11305000 5337000, -11261000 5381000, -11227000 5459000, -11178000 5518000, -11105000 5562000, -11051000 5670000, -10997000 5724000, -10953000 5812000))',
'Point (-12714000 5220000)',
'MultiPolygon (((-12157000 5694000, -12132000 5738000, -12093000 5782000, -12039000 5817000, -11956000 5836000, -11853000 5836000, -11795000 5792000, -11785000 5763000, -11760000 5738000, -11736000 5621000, -11716000 5587000, -11653000 5528000, -11643000 5503000, -11643000 5366000, -11653000 5337000, -11692000 5278000, -11731000 5249000, -11741000 5239000, -11839000 5205000, -11863000 5220000, -11927000 5288000, -11941000 5440000, -11951000 5450000, -12005000 5450000, -12020000 5450000, -12029000 5435000, -12054000 5435000, -12093000 5450000, -12132000 5503000, -12157000 5518000, -12166000 5543000, -12166000 5650000, -12157000 5694000),(-11995000 5680000, -12015000 5626000, -12005000 5582000, -11990000 5562000, -11927000 5547000, -11907000 5528000, -11883000 5479000, -11863000 5469000, -11829000 5469000, -11809000 5489000, -11814000 5577000, -11863000 5626000, -11912000 5704000, -11966000 5704000, -11995000 5680000)),((-11521000 5773000, -11496000 5851000, -11413000 5900000, -11389000 5890000, -11325000 5787000, -11320000 5724000, -11364000 5645000, -11418000 5640000, -11462000 5655000, -11491000 5699000, -11506000 5709000, -11521000 5773000)))'
})
# remove from selection
layer.selectByGeometry(selection_geometry, context,
Qgis.SelectBehavior.RemoveFromSelection,
Qgis.SelectGeometryRelationship.Intersect)
self.assertEqual(len(spy), 4)
self.assertCountEqual(set(f.id() for f in layer.selectedFeatures()),
{2220498092032, 3320043274243})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()), {
'Point (-12714000 5220000)',
'Polygon ((-12563000 5105000, -12470000 5102000, -12411000 4990000, -12411000 4970000, -12563000 4970000, -12563000 5105000))'
})
# intersect selection
selection_geometry = QgsGeometry.fromWkt(
'Polygon ((-12632118.89488627389073372 5457726.64942438062280416, -12862948.03383005037903786 5310835.37918743211776018, -12850357.35352402552962303 5046431.09276092518121004, -12716056.76359310187399387 4987674.58466614596545696, -12434864.90342522785067558 5113581.38772638700902462, -12632118.89488627389073372 5457726.64942438062280416))'
)
layer.selectByGeometry(selection_geometry, context,
Qgis.SelectBehavior.IntersectSelection,
Qgis.SelectGeometryRelationship.Within)
self.assertEqual(len(spy), 5)
self.assertCountEqual(set(f.id() for f in layer.selectedFeatures()),
{2220498092032})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()),
{'Point (-12714000 5220000)'})
layer.removeSelection()
self.assertFalse(layer.selectedFeatures())
self.assertEqual(len(spy), 6)
layer.removeSelection()
self.assertFalse(layer.selectedFeatures())
self.assertEqual(len(spy), 6)
# selection should depend on tile scale
selection_geometry = QgsGeometry.fromWkt(
'Polygon ((-12225020.2316580843180418 6030602.60334861185401678, -13521860.30317855626344681 5526975.39110779482871294, -12976264.15658413991332054 4821897.29397048708051443, -12019372.45332629978656769 4884850.69550053123384714, -11650045.83101624809205532 4754746.99900492746382952, -11469579.41329662501811981 5535369.17797833122313023, -11792740.20781794004142284 6110343.57862004917114973, -12225020.2316580843180418 6030602.60334861185401678))'
)
context = QgsSelectionContext()
context.setScale(137882080)
layer.selectByGeometry(selection_geometry, context,
Qgis.SelectBehavior.SetSelection,
Qgis.SelectGeometryRelationship.Intersect)
self.assertEqual(len(layer.selectedFeatures()), 5)
self.assertCountEqual(set(f.id() for f in layer.selectedFeatures()),
{33554432, 16777216, 0, 33554433, 33554438})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()), {
'MultiPolygon (((-12152000 5694000, -12132000 5733000, -12093000 5792000, -12034000 5812000, -11956000 5831000, -11858000 5831000, -11799000 5792000, -11780000 5773000, -11760000 5733000, -11741000 5616000, -11721000 5596000, -11662000 5538000, -11643000 5499000, -11643000 5362000, -11662000 5342000, -11682000 5283000, -11721000 5244000, -11741000 5244000, -11839000 5205000, -11858000 5225000, -11917000 5283000, -11936000 5440000, -11956000 5459000, -11995000 5459000, -12015000 5459000, -12034000 5440000, -12054000 5440000, -12093000 5459000, -12132000 5499000, -12152000 5518000, -12171000 5538000, -12171000 5655000, -12152000 5694000),(-11995000 5675000, -12015000 5636000, -11995000 5577000, -11995000 5557000, -11917000 5557000, -11917000 5538000, -11878000 5479000, -11858000 5479000, -11839000 5479000, -11799000 5499000, -11819000 5577000, -11858000 5636000, -11917000 5714000, -11956000 5714000, -11995000 5675000)),((-11525000 5773000, -11486000 5851000, -11408000 5909000, -11389000 5890000, -11330000 5792000, -11310000 5733000, -11369000 5655000, -11408000 5636000, -11467000 5655000, -11486000 5694000, -11506000 5714000, -11525000 5773000)))',
'MultiPoint ((-13052000 4471000),(-9275000 4016000),(-12201000 4261000),(-10885000 4143000),(-9828000 3992000),(-9534000 4711000),(-10371000 4965000),(-11403000 5049000),(-12499000 4775000),(-11501000 2607000),(-11452000 3703000),(-11085000 4951000),(-10493000 5919000),(-12714000 5220000),(-12607000 4290000),(-12249000 3703000),(-11687000 3331000))',
'MultiLineString ((-13091000 4188000, -13032000 4207000, -12974000 4285000, -12915000 4364000, -12778000 4442000, -12621000 4501000, -12445000 4481000, -12367000 4461000, -12328000 4461000, -12191000 4403000, -12113000 4344000, -11995000 4285000, -11858000 4285000, -11760000 4246000, -11467000 4227000, -11291000 4227000, -11173000 4285000, -11134000 4305000, -11017000 4305000, -10821000 4246000, -10645000 4246000, -10508000 4285000, -10430000 4344000, -10351000 4422000, -10195000 4520000, -10058000 4559000, -10058000 4579000, -9960000 4559000, -9921000 4540000, -9843000 4520000, -9745000 4461000, -9706000 4442000, -9549000 4422000, -9353000 4442000, -9236000 4520000, -9197000 4520000),(-12347000 4461000, -12367000 4403000, -12406000 4325000, -12426000 4305000, -12445000 4266000, -12465000 4207000, -12504000 4148000, -12621000 4109000, -12758000 4109000, -12797000 4090000, -12817000 4051000, -12856000 3992000, -12856000 3914000, -12856000 3816000, -12837000 3796000, -12797000 3777000),(-11662000 5792000, -11623000 5714000, -11584000 5636000, -11408000 5518000, -11330000 5420000, -11271000 5127000, -11252000 5049000, -11212000 4990000, -11193000 4872000, -11193000 4833000, -11193000 4814000, -11154000 4775000, -11056000 4696000, -11036000 4638000, -11075000 4559000, -11115000 4520000, -11134000 4442000, -11134000 4422000, -11056000 4227000, -11075000 4168000, -11095000 4148000, -11134000 4090000, -11134000 4031000, -11173000 3992000, -11212000 3914000, -11212000 3816000, -11193000 3757000, -11115000 3659000, -11075000 3542000, -11017000 3503000, -10978000 3444000, -10899000 3366000, -10860000 3327000, -10684000 3190000, -10664000 3150000, -10645000 3131000, -10645000 3053000, -10704000 2974000, -10723000 2955000, -10723000 2896000, -10704000 2818000, -10606000 2700000, -10528000 2661000),(-11310000 5342000, -11252000 5381000, -11232000 5459000, -11173000 5518000, -11115000 5557000, -11056000 5675000, -10997000 5733000, -10958000 5812000),(-10273000 4461000, -10254000 4364000, -10234000 4364000, -10214000 4344000, -10175000 4305000, -10097000 4305000, -10058000 4285000, -10038000 4227000, -10019000 4129000, -10019000 4109000, -9999000 4070000, -9921000 3953000, -9901000 3953000, -9804000 3933000, -9745000 3914000, -9706000 3835000, -9686000 3816000, -9627000 3796000, -9549000 3777000, -9530000 3757000, -9432000 3698000, -9353000 3679000, -9314000 3600000, -9256000 3561000),(-9843000 4520000, -9843000 4579000, -9823000 4598000, -9725000 4716000, -9725000 4735000, -9706000 4814000, -9647000 4912000, -9549000 5029000, -9530000 5146000, -9393000 5440000, -9314000 5479000, -9158000 5499000))',
'Polygon ((-11858000 4755000, -11799000 4892000, -11702000 4951000, -11643000 4951000, -11604000 4912000, -11565000 4892000, -11447000 4892000, -11349000 4833000, -11330000 4794000, -11291000 4775000, -11212000 4638000, -11212000 4579000, -11252000 4481000, -11271000 4442000, -11271000 4403000, -11291000 4383000, -11310000 4344000, -11408000 4305000, -11506000 4305000, -11525000 4325000, -11584000 4364000, -11623000 4422000, -11682000 4461000, -11780000 4520000, -11839000 4579000, -11878000 4657000, -11858000 4755000))',
'Polygon ((-13228000 4970000, -13208000 5009000, -13189000 5068000, -13169000 5127000, -13150000 5205000, -13110000 5244000, -13052000 5283000, -12954000 5264000, -12915000 5205000, -12876000 5185000, -12856000 5185000, -12797000 5146000, -12758000 5088000, -12680000 5088000, -12602000 5107000, -12465000 5107000, -12406000 4990000, -12406000 4951000, -12426000 4912000, -12445000 4892000, -12582000 4814000, -12621000 4775000, -12641000 4716000, -12680000 4657000, -12719000 4618000, -12837000 4598000, -12895000 4598000, -12934000 4618000, -12954000 4618000, -13032000 4618000, -13052000 4657000, -13130000 4657000, -13189000 4696000, -13228000 4775000, -13228000 4814000, -13228000 4912000, -13228000 4970000))'
})
self.assertEqual(len(spy), 7)
# removing features should NOT depend on the scale
context.setScale(237882080)
layer.selectByGeometry(selection_geometry, context,
Qgis.SelectBehavior.RemoveFromSelection,
Qgis.SelectGeometryRelationship.Intersect)
self.assertFalse(layer.selectedFeatures())
self.assertEqual(len(spy), 8)
# single feature selection
selection_geometry = QgsGeometry.fromWkt(
'Polygon ((-10486370.9139375202357769 3807467.1023839432746172, -10528246.57568679377436638 3799853.34570225700736046, -10490177.79227836430072784 3735136.41390792420133948, -10486370.9139375202357769 3807467.1023839432746172))'
)
layer.selectByGeometry(
selection_geometry, context, Qgis.SelectBehavior.SetSelection,
Qgis.SelectGeometryRelationship.Intersect,
Qgis.SelectionFlags(Qgis.SelectionFlag.SingleFeatureSelection))
self.assertEqual(len(layer.selectedFeatures()), 1)
self.assertCountEqual(set(f.id() for f in layer.selectedFeatures()),
{33554436})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()), {
'Polygon ((-10958000 3835000, -10958000 3796000, -10919000 3835000, -10841000 3874000, -10684000 3992000, -10567000 4031000, -10410000 4031000, -10332000 3992000, -10254000 3914000, -10136000 3914000, -10058000 3874000, -10019000 3796000, -10019000 3757000, -10058000 3718000, -10097000 3718000, -10254000 3796000, -10332000 3796000, -10371000 3757000, -10371000 3718000, -10371000 3679000, -10332000 3640000, -10332000 3561000, -10410000 3483000, -10449000 3405000, -10488000 3366000, -10645000 3327000, -10723000 3366000, -10762000 3405000, -10801000 3444000, -10762000 3483000, -10801000 3522000, -10841000 3561000, -10919000 3561000, -10958000 3600000, -10958000 3640000, -10958000 3679000, -10958000 3718000, -10997000 3796000, -10958000 3835000))'
})
self.assertEqual(len(spy), 9)
# select again
layer.selectByGeometry(
selection_geometry, context, Qgis.SelectBehavior.SetSelection,
Qgis.SelectGeometryRelationship.Intersect,
Qgis.SelectionFlags(Qgis.SelectionFlag.SingleFeatureSelection))
self.assertEqual(len(layer.selectedFeatures()), 1)
self.assertCountEqual(set(f.id() for f in layer.selectedFeatures()),
{33554436})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()), {
'Polygon ((-10958000 3835000, -10958000 3796000, -10919000 3835000, -10841000 3874000, -10684000 3992000, -10567000 4031000, -10410000 4031000, -10332000 3992000, -10254000 3914000, -10136000 3914000, -10058000 3874000, -10019000 3796000, -10019000 3757000, -10058000 3718000, -10097000 3718000, -10254000 3796000, -10332000 3796000, -10371000 3757000, -10371000 3718000, -10371000 3679000, -10332000 3640000, -10332000 3561000, -10410000 3483000, -10449000 3405000, -10488000 3366000, -10645000 3327000, -10723000 3366000, -10762000 3405000, -10801000 3444000, -10762000 3483000, -10801000 3522000, -10841000 3561000, -10919000 3561000, -10958000 3600000, -10958000 3640000, -10958000 3679000, -10958000 3718000, -10997000 3796000, -10958000 3835000))'
})
self.assertEqual(len(spy), 9)
# with toggle mode
layer.selectByGeometry(
selection_geometry, context, Qgis.SelectBehavior.SetSelection,
Qgis.SelectGeometryRelationship.Intersect,
Qgis.SelectionFlags(Qgis.SelectionFlag.SingleFeatureSelection
| Qgis.SelectionFlag.ToggleSelection))
self.assertFalse(layer.selectedFeatures())
self.assertEqual(len(spy), 10)
layer.selectByGeometry(
selection_geometry, context, Qgis.SelectBehavior.SetSelection,
Qgis.SelectGeometryRelationship.Intersect,
Qgis.SelectionFlags(Qgis.SelectionFlag.SingleFeatureSelection
| Qgis.SelectionFlag.ToggleSelection))
self.assertEqual(len(layer.selectedFeatures()), 1)
self.assertCountEqual(set(f.id() for f in layer.selectedFeatures()),
{33554436})
self.assertCountEqual(
set(f.geometry().asWkt(-3) for f in layer.selectedFeatures()), {
'Polygon ((-10958000 3835000, -10958000 3796000, -10919000 3835000, -10841000 3874000, -10684000 3992000, -10567000 4031000, -10410000 4031000, -10332000 3992000, -10254000 3914000, -10136000 3914000, -10058000 3874000, -10019000 3796000, -10019000 3757000, -10058000 3718000, -10097000 3718000, -10254000 3796000, -10332000 3796000, -10371000 3757000, -10371000 3718000, -10371000 3679000, -10332000 3640000, -10332000 3561000, -10410000 3483000, -10449000 3405000, -10488000 3366000, -10645000 3327000, -10723000 3366000, -10762000 3405000, -10801000 3444000, -10762000 3483000, -10801000 3522000, -10841000 3561000, -10919000 3561000, -10958000 3600000, -10958000 3640000, -10958000 3679000, -10958000 3718000, -10997000 3796000, -10958000 3835000))'
})
self.assertEqual(len(spy), 11)
def spatialInfo(self):
ret = []
if not self.table.geomType:
return ret
tbl = [
(QApplication.translate("DBManagerPlugin", "Column:"),
self.table.geomColumn),
(QApplication.translate("DBManagerPlugin", "Geometry:"),
self.table.geomType),
(QApplication.translate("DBManagerPlugin",
"Qgis Geometry type:"),
Qgis.featureType(self.table.wkbType))
]
# only if we have info from geometry_columns
if self.table.geomDim:
tbl.append(
(QApplication.translate(
"DBManagerPlugin",
"Dimension:"),
self.table.geomDim))
srid = self.table.srid if self.table.srid else -1
if srid != -1:
sr_info = (
self.table.database().connector.getSpatialRefInfo(srid))
else:
sr_info = QApplication.translate("DBManagerPlugin",
"Undefined")
if sr_info:
tbl.append(
(QApplication.translate(
"DBManagerPlugin", "Spatial ref:"),
u"{0} ({1})".format(sr_info, srid)))
# estimated extent
if not self.table.estimatedExtent:
# estimated extent information is not displayed yet, so just block
# table signals to avoid double refreshing
# (infoViewer->refreshEstimatedExtent->tableChanged->infoViewer)
self.table.blockSignals(True)
self.table.refreshTableEstimatedExtent()
self.table.blockSignals(False)
if self.table.estimatedExtent:
estimated_extent_str = (u"{:.9f}, {:.9f} - {:.9f}, "
u"{:.9f}".format(
*self.table.estimatedExtent))
tbl.append(
(QApplication.translate(
"DBManagerPlugin", "Estimated extent:"),
estimated_extent_str))
# extent
extent_str = None
if self.table.extent and len(self.table.extent) == 4:
extent_str = (u"{:.9f}, {:.9f} - {:.9f}, "
u"{:.9f}".format(*self.table.extent))
elif self.table.rowCount > 0 or self.table.estimatedRowCount > 0:
# Can't calculate an extent on empty layer
extent_str = QApplication.translate(
"DBManagerPlugin",
'(unknown) (<a href="action:extent/get">find out</a>)')
if extent_str:
tbl.append(
(QApplication.translate(
"DBManagerPlugin", "Extent:"),
extent_str))
ret.append(HtmlTable(tbl))
# Handle extent update metadata
if (self.table.extent
and self.table.extent != self.table.estimatedExtent
and self.table.canUpdateMetadata()):
ret.append(
HtmlParagraph(
QApplication.translate(
"DBManagerPlugin",
(u'<warning> Metadata extent is different from'
u'real extent. You should <a href="action:extent'
u'/update">update it</a>!'))))
# is there an entry in geometry_columns?
if self.table.geomType.lower() == 'geometry':
ret.append(
HtmlParagraph(
QApplication.translate(
"DBManagerPlugin",
"<warning> There is no entry in geometry_columns!")))
# find out whether the geometry column has spatial index on it
if not self.table.isView:
if not self.table.hasSpatialIndex():
ret.append(
HtmlParagraph(
QApplication.translate(
"DBManagerPlugin",
(u'<warning> No spatial index defined (<a href='
u'"action:spatialindex/create">'
u'create it</a>).'))))
return ret
def test_rename_dataset(self):
"""
Test QgsFileUtils.renameDataset
"""
base_path = tempfile.mkdtemp()
for ext in ['shp', 'dbf', 'prj', 'qml', 'shx']:
shutil.copy(f'{unitTestDataPath()}/lines.{ext}',
f'{base_path}/lines.{ext}')
shutil.copy(f'{unitTestDataPath()}/lines.{ext}',
f'{base_path}/lines.{ext}')
self.assertTrue(os.path.exists(f'{base_path}/lines.shp'))
res, error = QgsFileUtils.renameDataset(
f'{base_path}/lines.shp', f'{base_path}/other_lines.shp')
self.assertTrue(res)
for ext in ['shp', 'dbf', 'prj', 'qml', 'shx']:
self.assertTrue(os.path.exists(f'{base_path}/other_lines.{ext}'))
self.assertFalse(os.path.exists(f'{base_path}/lines.{ext}'))
# skip qml file
res, error = QgsFileUtils.renameDataset(
f'{base_path}/other_lines.shp', f'{base_path}/other_lines2.shp',
Qgis.FileOperationFlags())
self.assertTrue(res)
for ext in ['shp', 'dbf', 'prj', 'shx']:
self.assertTrue(os.path.exists(f'{base_path}/other_lines2.{ext}'))
self.assertFalse(os.path.exists(f'{base_path}/other_lines.{ext}'))
self.assertFalse(os.path.exists(f'{base_path}/other_lines2.qml'))
self.assertTrue(os.path.exists(f'{base_path}/other_lines.qml'))
# try changing extension -- sidecars won't be renamed
res, error = QgsFileUtils.renameDataset(
f'{base_path}/other_lines2.shp', f'{base_path}/other_lines2.txt',
Qgis.FileOperationFlags())
self.assertFalse(error)
self.assertTrue(res)
self.assertFalse(os.path.exists(f'{base_path}/other_lines2.shp'))
self.assertTrue(os.path.exists(f'{base_path}/other_lines2.txt'))
for ext in ['dbf', 'prj', 'shx']:
self.assertTrue(os.path.exists(f'{base_path}/other_lines2.{ext}'))
for ext in ['shp', 'dbf', 'prj', 'qml', 'shx']:
shutil.copy(f'{unitTestDataPath()}/lines.{ext}',
f'{base_path}/ll.{ext}')
shutil.copy(f'{unitTestDataPath()}/lines.{ext}',
f'{base_path}/ll.{ext}')
# file name clash
with open(f'{base_path}/yy.shp', 'wt') as f:
f.write('')
res, error = QgsFileUtils.renameDataset(f'{base_path}/ll.shp',
f'{base_path}/yy.shp',
Qgis.FileOperationFlags())
self.assertFalse(res)
self.assertTrue(error)
# nothing should be renamed
for ext in ['shp', 'dbf', 'prj', 'qml', 'shx']:
self.assertTrue(os.path.exists(f'{base_path}/ll.{ext}'))
# sidecar clash
with open(f'{base_path}/yyy.shx', 'wt') as f:
f.write('')
res, error = QgsFileUtils.renameDataset(f'{base_path}/ll.shp',
f'{base_path}/yyy.shp')
self.assertFalse(res)
self.assertTrue(error)
# no files should have been renamed
for ext in ['shp', 'dbf', 'prj', 'qml']:
self.assertTrue(os.path.exists(f'{base_path}/ll.{ext}'))
self.assertFalse(os.path.exists(f'{base_path}/yyy.{ext}'))
self.assertTrue(os.path.exists(f'{base_path}/ll.shx'))
# try renaming missing file
res, error = QgsFileUtils.renameDataset('/not a file.txt',
f'{base_path}/not a file.txt',
Qgis.FileOperationFlags())
self.assertFalse(res)
self.assertTrue(error)
def doCheck(self, method, parameters, context, feedback,
ignore_ring_self_intersection):
flags = QgsGeometry.FlagAllowSelfTouchingHoles if ignore_ring_self_intersection else QgsGeometry.ValidityFlags(
)
source = self.parameterAsSource(parameters, self.INPUT_LAYER, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT_LAYER))
(valid_output_sink,
valid_output_dest_id) = self.parameterAsSink(parameters,
self.VALID_OUTPUT,
context, source.fields(),
source.wkbType(),
source.sourceCrs())
valid_count = 0
invalid_fields = source.fields()
invalid_fields.append(
QgsField('_errors', QVariant.String, 'string', 255))
(invalid_output_sink, invalid_output_dest_id) = self.parameterAsSink(
parameters, self.INVALID_OUTPUT, context, invalid_fields,
source.wkbType(), source.sourceCrs())
invalid_count = 0
error_fields = QgsFields()
error_fields.append(QgsField('message', QVariant.String, 'string',
255))
(error_output_sink, error_output_dest_id) = self.parameterAsSink(
parameters, self.ERROR_OUTPUT, context, error_fields,
QgsWkbTypes.Point, source.sourceCrs())
error_count = 0
features = source.getFeatures(
QgsFeatureRequest(),
QgsProcessingFeatureSource.FlagSkipGeometryValidityChecks)
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
geom = inFeat.geometry()
attrs = inFeat.attributes()
valid = True
if not geom.isNull() and not geom.isEmpty():
errors = list(
geom.validateGeometry(
Qgis.GeometryValidationEngine(method), flags))
if errors:
valid = False
reasons = []
for error in errors:
errFeat = QgsFeature()
error_geom = QgsGeometry.fromPointXY(error.where())
errFeat.setGeometry(error_geom)
errFeat.setAttributes([error.what()])
if error_output_sink:
error_output_sink.addFeature(
errFeat, QgsFeatureSink.FastInsert)
error_count += 1
reasons.append(error.what())
reason = "\n".join(reasons)
if len(reason) > 255:
reason = reason[:252] + '…'
attrs.append(reason)
outFeat = QgsFeature()
outFeat.setGeometry(geom)
outFeat.setAttributes(attrs)
if valid:
if valid_output_sink:
valid_output_sink.addFeature(outFeat,
QgsFeatureSink.FastInsert)
valid_count += 1
else:
if invalid_output_sink:
invalid_output_sink.addFeature(outFeat,
QgsFeatureSink.FastInsert)
invalid_count += 1
feedback.setProgress(int(current * total))
results = {
self.VALID_COUNT: valid_count,
self.INVALID_COUNT: invalid_count,
self.ERROR_COUNT: error_count
}
if valid_output_sink:
results[self.VALID_OUTPUT] = valid_output_dest_id
if invalid_output_sink:
results[self.INVALID_OUTPUT] = invalid_output_dest_id
if error_output_sink:
results[self.ERROR_OUTPUT] = error_output_dest_id
return results
def spatialInfo(self):
ret = []
if not self.table.geomType:
return ret
tbl = [
(QApplication.translate("DBManagerPlugin", "Column:"),
self.table.geomColumn),
(QApplication.translate("DBManagerPlugin", "Geometry:"),
self.table.geomType),
(QApplication.translate("DBManagerPlugin",
"Qgis Geometry type:"),
Qgis.featureType(self.table.wkbType))
]
# only if we have info from geometry_columns
if self.table.geomDim:
tbl.append(
(QApplication.translate(
"DBManagerPlugin",
"Dimension:"),
self.table.geomDim))
srid = self.table.srid if self.table.srid else -1
if srid != -1:
sr_info = (
self.table.database().connector.getSpatialRefInfo(srid))
else:
sr_info = QApplication.translate("DBManagerPlugin",
"Undefined")
if sr_info:
tbl.append(
(QApplication.translate(
"DBManagerPlugin", "Spatial ref:"),
u"{0} ({1})".format(sr_info, srid)))
# estimated extent
if not self.table.estimatedExtent:
# estimated extent information is not displayed yet, so just block
# table signals to avoid double refreshing
# (infoViewer->refreshEstimatedExtent->tableChanged->infoViewer)
self.table.blockSignals(True)
self.table.refreshTableEstimatedExtent()
self.table.blockSignals(False)
if self.table.estimatedExtent:
estimated_extent_str = (u"{:.9f}, {:.9f} - {:.9f}, "
u"{:.9f}".format(
*self.table.estimatedExtent))
tbl.append(
(QApplication.translate(
"DBManagerPlugin", "Estimated extent:"),
estimated_extent_str))
# extent
extent_str = None
if self.table.extent and len(self.table.extent) == 4:
extent_str = (u"{:.9f}, {:.9f} - {:.9f}, "
u"{:.9f}".format(*self.table.extent))
elif self.table.rowCount > 0 or self.table.estimatedRowCount > 0:
# Can't calculate an extent on empty layer
extent_str = QApplication.translate(
"DBManagerPlugin",
'(unknown) (<a href="action:extent/get">find out</a>)')
if extent_str:
tbl.append(
(QApplication.translate(
"DBManagerPlugin", "Extent:"),
extent_str))
ret.append(HtmlTable(tbl))
# Handle extent update metadata
if (self.table.extent and
self.table.extent != self.table.estimatedExtent and
self.table.canUpdateMetadata()):
ret.append(
HtmlParagraph(
QApplication.translate(
"DBManagerPlugin",
(u'<warning> Metadata extent is different from'
u'real extent. You should <a href="action:extent'
u'/update">update it</a>!'))))
# is there an entry in geometry_columns?
if self.table.geomType.lower() == 'geometry':
ret.append(
HtmlParagraph(
QApplication.translate(
"DBManagerPlugin",
"<warning> There is no entry in geometry_columns!")))
# find out whether the geometry column has spatial index on it
if not self.table.isView:
if not self.table.hasSpatialIndex():
ret.append(
HtmlParagraph(
QApplication.translate(
"DBManagerPlugin",
(u'<warning> No spatial index defined (<a href='
u'"action:spatialindex/create">'
u'create it</a>).'))))
return ret
