def _add_tabular_layer(self, tabular_layer, layer_name, save_style=False):
"""Add a tabular layer to the folder.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:param save_style: If we have to save a QML too. Default to False.
:type save_style: bool
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
output = QFileInfo(
self.uri.filePath(layer_name + '.csv'))
QgsVectorFileWriter.writeAsVectorFormat(
tabular_layer,
output.absoluteFilePath(),
'utf-8',
QgsCoordinateTransform(),
'CSV')
if save_style:
style_path = QFileInfo(self.uri.filePath(layer_name + '.qml'))
tabular_layer.saveNamedStyle(style_path.absoluteFilePath())
assert output.exists()
return True, output.baseName()
def _add_tabular_layer(self, tabular_layer, layer_name):
"""Add a tabular layer to the folder.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
output = QFileInfo(
self.uri.filePath(layer_name + '.csv'))
QgsVectorFileWriter.writeAsVectorFormat(
tabular_layer,
output.absoluteFilePath(),
'utf-8',
None,
'CSV')
assert output.exists()
return True, output.baseName()
def writeVectorLayerToShape(vlayer, outputPath, encoding):
mCodec = QTextCodec.codecForName(encoding)
if not mCodec:
return False
#Here we should check that the output path is valid
QgsVectorFileWriter.writeAsVectorFormat(vlayer, outputPath, encoding, vlayer.dataProvider().crs(), "ESRI Shapefile", False)
return True
def exportVector(layer, sln, layersFolder, restrictToExtent, iface,
extent, precision, crs, minify):
canvas = iface.mapCanvas()
cleanLayer = writeTmpLayer(layer, restrictToExtent, iface, extent)
if is25d(layer, canvas, restrictToExtent, extent):
add25dAttributes(cleanLayer, layer, canvas)
tmpPath = os.path.join(layersFolder, sln + ".json")
path = os.path.join(layersFolder, sln + ".js")
options = []
if precision != "maintain":
options.append("COORDINATE_PRECISION=" + unicode(precision))
QgsVectorFileWriter.writeAsVectorFormat(cleanLayer, tmpPath, "utf-8", crs,
'GeoJson', 0,
layerOptions=options)
with open(path, mode="w", encoding="utf8") as f:
f.write("var %s = " % ("json_" + sln))
with open(tmpPath, encoding="utf8") as tmpFile:
for line in tmpFile:
if minify:
line = line.strip("\n\t ")
line = removeSpaces(line)
f.write(line)
os.remove(tmpPath)
fields = layer.fields()
for field in fields:
exportImages(layer, field.name(), layersFolder + "/tmp.tmp")
def TussenTelling(selectie_gebouwen, outputTable, outputFeatures):
if outputTable:
statistics_fields = ["AZ_T","PZ_T","PVT_T","WZC_T","SOM_T"]
MaakOverzichtstabel(selectie_gebouwen, statistics_fields, outputTable)
if outputFeatures:
flType = findOGRtype(outputFeatures)
QgsVectorFileWriter.writeAsVectorFormat(selectie_gebouwen , outputFeatures, "utf-8", None, flType )
def export_filter_layer(self, ext='xlsx'):
'''
export a filter-layer (opens user-input) to excel or kml
'''
try:
res = self.get_filterlayer()
except:
traceback.print_exc()
return
if not res:
return
category, layer = res
file_filter = EXCEL_FILTER if ext == 'xlsx' else KML_FILTER
filepath = browse_file(None, 'Export', file_filter, save=True,
parent=self)
if not filepath:
return
driver = 'XLSX' if ext == 'xlsx'else 'KML'
#fields = []
#for i, f in enumerate(layer.fields()):
#if layer.editorWidgetV2(i) == 'Hidden':
#continue
#fields.append(f.name())
try:
QgsVectorFileWriter.writeAsVectorFormat(
layer, filepath, "utf-8", None, driver, False)
#attributes=fields)
title = 'Speicherung erfolgreich'
msg = 'Die Daten wurden erfolgreich exportiert.'
except Exception as e:
title = 'Fehler'
msg = 'Fehler bei der Speicherung: \n {}'.format(str(e))
QtGui.QMessageBox.information(
self, title, msg)
def run(self):
tempLayer = self.createGridLayer('temp', 'Multipolygon', self.crs.geographicCRSAuthId())
self.populateQgsLayer(self.index, self.stopScale, tempLayer, self.mi)
useMemory = True
if not self.layer:
useMemory = False
self.layer = self.createGridLayer('Grid Zones', 'Multipolygon', self.crs.authid())
for feature in tempLayer.getFeatures():
if self.stopped:
del tempLayer
tempLayer = None
self.aux.userCanceled.emit()
return
geom = feature.geometry()
reprojected = self.reprojectGridZone(geom)
self.insertGridZoneIntoQgsLayer(self.layer, reprojected, feature.attributes())
self.aux.stepProcessed.emit()
del tempLayer
tempLayer = None
self.aux.stepProcessed.emit()
if not useMemory:
QgsVectorFileWriter.writeAsVectorFormat(self.layer, self.output, "utf-8", None, "ESRI Shapefile")
self.aux.processFinished.emit()
def convert_geojson_to_shapefile(geojson_path):
"""Convert geojson file to shapefile.
It will create a necessary file next to the geojson file. It will not
affect another files (e.g. .xml, .qml, etc).
:param geojson_path: The path to geojson file.
:type geojson_path: basestring
:returns: True if shapefile layer created, False otherwise.
:rtype: bool
"""
layer = QgsVectorLayer(geojson_path, 'vector layer', 'ogr')
if not layer.isValid():
return False
# Construct shapefile path
shapefile_path = os.path.splitext(geojson_path)[0] + '.shp'
QgsVectorFileWriter.writeAsVectorFormat(
layer,
shapefile_path,
'utf-8',
layer.crs(),
'ESRI Shapefile')
if os.path.exists(shapefile_path):
return True
return False
def test03_SaveAsCSV(self):
"""Save layer to a CSV file"""
self._testAvailable() or self.skipTest("Not available")
layer = self._testLayer(self.fileName)
outfile = self.testDataPath(u"{}.csv".format(self.layerName), output=True)
QgsVectorFileWriter.writeAsVectorFormat(layer, outfile, "UTF-8", layer.crs(),
"CSV", layerOptions=["LINEFORMAT=LF", "GEOMETRY=AS_XY"])
expfile = unitTestDataPath("{}.csv".format(TC01_Attribute.layerName), own=True)
assert compareFile(outfile, expfile, delimiter=",") == 0, "unexpected csv output"
def conversion(input_name,output_name,input_json,output_json):
vlayer = QgsVectorLayer(input_name,'shp','ogr')
error=QW.writeAsVectorFormat(vlayer, input_json,'utf-8',None,'GeoJSON')
if error == QW.NoError:
print "succeed in json conversion"
convert(input_json+'.geojson',output_json+'.geojson')
jlayer = QgsVectorLayer(output_json+'.geojson','json','ogr')
err_shp = QW.writeAsVectorFormat(jlayer, output_name, "utf-8", None, "ESRI Shapefile")
if error == QW.NoError:
print "succeed in shp conversion"
def testGeoPackage(self):
'''Test GeoPackage'''
layer = QgsVectorLayer(os.path.join(os.path.dirname(__file__), "data","airports.gpkg"),
"test", "ogr")
self.assertTrue(layer.isValid())
filepath = os.path.join(tempfile.mkdtemp(), str(time.time()) + ".gpkg")
QgsVectorFileWriter.writeAsVectorFormat(layer, filepath, 'utf-8', layer.crs(), 'GPKG')
layer = QgsVectorLayer(filepath, "test", "ogr")
self.assertTrue(layer.isValid())
def writeDBF(pos, pp, pr, save_file, inpname, param, idx):
pos.startEditing()
for i in range(len(pp)):
feat = QgsFeature()
feat.setAttributes(pp[i])
pr.addFeatures([feat])
epsgCode = pos.crs().authid()
QgsVectorFileWriter.writeAsVectorFormat(pos, save_file + param + '.dbf', "utf-8",
QgsCoordinateReferenceSystem(epsgCode), "DBF file")
ll = QgsVectorLayer(save_file + param + '.dbf', inpname[:len(inpname) - 4] + param, "ogr")
QgsProject.instance().addMapLayer(ll, False)
nn = QgsLayerTreeLayer(ll)
idx.insertChildNode(0, nn)
nn.setCustomProperty("showFeatureCount", True)
def testInteger64WriteTabfile(self):
"""Check writing Integer64 fields to an MapInfo tabfile (which does not support that type)."""
ml = QgsVectorLayer(("Point?crs=epsg:4326&field=int8:int8"), "test", "memory")
self.assertIsNotNone(ml, "Provider not initialized")
self.assertTrue(ml.isValid(), "Source layer not valid")
provider = ml.dataProvider()
self.assertIsNotNone(provider)
ft = QgsFeature()
ft.setAttributes([2123456789])
res, features = provider.addFeatures([ft])
self.assertTrue(res)
self.assertTrue(features)
dest_file_name = os.path.join(str(QDir.tempPath()), "integer64.tab")
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(ml, dest_file_name, "utf-8", crs, "MapInfo File")
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer("{}|layerid=0".format(dest_file_name), "test", "ogr")
fields = created_layer.dataProvider().fields()
self.assertEqual(fields.at(fields.indexFromName("int8")).type(), QVariant.Double)
f = next(created_layer.getFeatures(QgsFeatureRequest()))
int8_idx = created_layer.fields().lookupField("int8")
self.assertEqual(f.attributes()[int8_idx], 2123456789)
def saveGipod2file(self, filename, ftype="ESRI Shapefile" ):
layerOptions = []
datasourceOptions = []
if ftype == "CSV":
layerOptions += ["GEOMETRY=AS_XY","SEPARATOR=SEMICOLON"]
if ftype == "KML":
datasourceOptions += ["NameField=owner"]
srs = QgsCoordinateReferenceSystem(self.CRS)
fpath, name = os.path.split(filename)
if fpath and os.path.exists(fpath):
error, errormsg = QgsVectorFileWriter.writeAsVectorFormat(self.gipodlayer , filename, "utf-8", self.gipodlayer.crs(), ftype, layerOptions= layerOptions, datasourceOptions= datasourceOptions )
if error == QgsVectorFileWriter.NoError:
if ftype == "CSV":
uri =( "file:///%s?delimiter=%s&xField=%s&yField=%s&crs=%s" % (
filename, ";", "X", "Y", self.gipodlayer.crs().authid()) ).replace("\\","/")
self.gipodlayer = QgsVectorLayer(uri, self.layername, "delimitedtext")
else:
self.gipodlayer = QgsVectorLayer( filename, self.layername, "ogr")
self.gipodProvider = self.gipodlayer.dataProvider()
else:
raise gipodError( str(error.hasError()) , errormsg )
else:
raise gipodError( fpath + " doesn't exist" )
def testWriteWithBinaryField(self):
"""
Test writing with a binary field
:return:
"""
basetestpath = tempfile.mkdtemp()
tmpfile = os.path.join(basetestpath, 'binaryfield.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('binfield', ogr.OFTBinary))
lyr.CreateField(ogr.FieldDefn('binfield2', ogr.OFTBinary))
f = None
ds = None
vl = QgsVectorLayer(tmpfile)
self.assertTrue(vl.isValid())
# check that 1 of its fields is a bool
fields = vl.fields()
self.assertEqual(fields.at(fields.indexFromName('binfield')).type(), QVariant.ByteArray)
dp = vl.dataProvider()
f = QgsFeature(fields)
bin_1 = b'xxx'
bin_2 = b'yyy'
bin_val1 = QByteArray(bin_1)
bin_val2 = QByteArray(bin_2)
f.setAttributes([1, 'str', 100, bin_val1, bin_val2])
self.assertTrue(dp.addFeature(f))
# write a gpkg package with a binary field
filename = os.path.join(str(QDir.tempPath()), 'with_bin_field')
rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat(vl,
filename,
'utf-8',
vl.crs(),
'GPKG')
self.assertEqual(rc, QgsVectorFileWriter.NoError)
# open the resulting geopackage
vl = QgsVectorLayer(filename + '.gpkg', '', 'ogr')
self.assertTrue(vl.isValid())
fields = vl.fields()
# test type of converted field
idx = fields.indexFromName('binfield')
self.assertEqual(fields.at(idx).type(), QVariant.ByteArray)
idx2 = fields.indexFromName('binfield2')
self.assertEqual(fields.at(idx2).type(), QVariant.ByteArray)
# test values
self.assertEqual(vl.getFeature(1).attributes()[idx], bin_val1)
self.assertEqual(vl.getFeature(1).attributes()[idx2], bin_val2)
del vl
os.unlink(filename + '.gpkg')
def testAddZ(self):
"""Check adding z values to non z input."""
input = QgsVectorLayer(
'Point?crs=epsg:4326&field=name:string(20)',
'test',
'memory')
self.assertTrue(input.isValid(), 'Provider not initialized')
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(10, 10)))
myResult, myFeatures = input.dataProvider().addFeatures([ft])
self.assertTrue(myResult)
self.assertTrue(myFeatures)
dest_file_name = os.path.join(str(QDir.tempPath()), 'add_z.geojson')
options = QgsVectorFileWriter.SaveVectorOptions()
options.overrideGeometryType = QgsWkbTypes.PointZ
options.driverName = 'GeoJSON'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
input,
dest_file_name,
options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError, error_message)
# Open result and check
created_layer = QgsVectorLayer(dest_file_name, 'test', 'ogr')
self.assertTrue(created_layer.isValid())
f = next(created_layer.getFeatures(QgsFeatureRequest()))
self.assertEqual(f.geometry().asWkt(), 'PointZ (10 10 0)')
def testValueConverter(self):
"""Tests writing a layer with a field value converter."""
ml = QgsVectorLayer(("Point?field=nonconv:int&field=ignored:string&field=converted:int"), "test", "memory")
self.assertIsNotNone(ml, "Provider not initialized")
self.assertTrue(ml.isValid(), "Source layer not valid")
provider = ml.dataProvider()
self.assertIsNotNone(provider)
self.assertEqual(ml.fields().count(), 3)
ft = QgsFeature()
ft.setAttributes([1, "ignored", 3])
res, features = provider.addFeatures([ft])
self.assertTrue(res)
self.assertTrue(features)
dest_file_name = os.path.join(str(QDir.tempPath()), "value_converter.shp")
converter = TestFieldValueConverter(ml)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
"utf-8",
QgsCoordinateReferenceSystem(),
"ESRI Shapefile",
attributes=[0, 2],
fieldValueConverter=converter,
)
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer("{}|layerid=0".format(dest_file_name), "test", "ogr")
self.assertEqual(created_layer.fields().count(), 2)
f = next(created_layer.getFeatures(QgsFeatureRequest()))
self.assertEqual(f["nonconv"], 1)
self.assertEqual(f["conv_attr"], "converted_val")
def read_from_qgis_native(self, qgis_layer):
"""Read and unpack vector data from qgis layer QgsVectorLayer.
A stub is used now:
save all data in a file,
then call safe.read_from_file
Raises:
* TypeError if qgis is not avialable
* IOError if can't store temporary file
"""
# FIXME (DK): this branch isn't covered by test
if not QGIS_IS_AVAILABLE:
msg = ('Used data is QgsVectorLayer instance, '
'but QGIS is not available.')
raise TypeError(msg)
base_name = unique_filename()
file_name = base_name + '.shp'
error = QgsVectorFileWriter.writeAsVectorFormat(
qgis_layer,
file_name,
"UTF8",
qgis_layer.crs(),
"ESRI Shapefile"
)
if error != QgsVectorFileWriter.NoError:
# FIXME (DK): this branch isn't covered by test
msg = ('Can not save data in temporary file.')
raise IOError(msg)
# Write keywords if any
write_keywords(self.keywords, base_name + '.keywords')
self.read_from_file(file_name)
def testWriteShapefileWithMultiConversion(self):
"""Check writing geometries to an ESRI shapefile with conversion to multi."""
ml = QgsVectorLayer(("Point?crs=epsg:4326&field=id:int"), "test", "memory")
self.assertIsNotNone(ml, "Provider not initialized")
self.assertTrue(ml.isValid(), "Source layer not valid")
provider = ml.dataProvider()
self.assertIsNotNone(provider)
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromWkt("Point (1 2)"))
ft.setAttributes([1])
res, features = provider.addFeatures([ft])
self.assertTrue(res)
self.assertTrue(features)
dest_file_name = os.path.join(str(QDir.tempPath()), "to_multi.shp")
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml, dest_file_name, "utf-8", crs, "ESRI Shapefile", forceMulti=True
)
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer("{}|layerid=0".format(dest_file_name), "test", "ogr")
f = next(created_layer.getFeatures(QgsFeatureRequest()))
g = f.geometry()
wkt = g.exportToWkt()
expWkt = "MultiPoint ((1 2))"
self.assertTrue(
compareWkt(expWkt, wkt),
"saving geometry with multi conversion failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt),
)
def return_batch_route(self, features):
"""Save and/or display the routes retrieved"""
osrm_batch_route_layer = QgsVectorLayer(
"Linestring?crs=epsg:4326&field=id:integer"
"&field=total_time:integer(20)&field=distance:integer(20)",
"routes_osrm{}".format(self.nb_done), "memory")
provider = osrm_batch_route_layer.dataProvider()
provider.addFeatures(features)
QgsMapLayerRegistry.instance().addMapLayer(osrm_batch_route_layer)
if self.filename:
error = QgsVectorFileWriter.writeAsVectorFormat(
osrm_batch_route_layer, self.filename,
self.encoding, None, "ESRI Shapefile")
if error != QgsVectorFileWriter.NoError:
self.iface.messageBar().pushMessage(
"Error",
"Can't save the result into {} - Output have been "
"added to the canvas (see QGis log for error trace"
"back)".format(self.filename), duration=10)
QgsMessageLog.logMessage(
'OSRM-plugin error report :\n {}'.format(error),
level=QgsMessageLog.WARNING)
self.iface.setActiveLayer(osrm_batch_route_layer)
return -1
else:
QtGui.QMessageBox.information(
self.iface.mainWindow(), 'Info',
"Result saved in {}".format(self.filename))
if self.check_add_layer.isChecked():
self.iface.setActiveLayer(osrm_batch_route_layer)
else:
QgsMapLayerRegistry.instance().removeMapLayer(
osrm_batch_route_layer.id())
self.iface.messageBar().clearWidgets()
def write_temporary_vector_layer_to_disk(vlayer, style=None, replace_in_legend=True):
import os
from qgis.utils import iface
from mole import oeq_global
if oeq_global.OeQ_project_name() == '':
iface.actionSaveProjectAs().trigger()
layer_name = vlayer.name()
layer_crs = vlayer.crs()
path = os.path.join(oeq_global.OeQ_project_path(), layer_name + '.shp')
error = QgsVectorFileWriter.writeAsVectorFormat(vlayer, path, "System", layer_crs, 'ESRI Shapefile')
if error == QgsVectorFileWriter.NoError:
if replace_in_legend:
QgsMapLayerRegistry.instance().removeMapLayer(vlayer.id())
rewritten_layer = iface.addVectorLayer(path, layer_name, "ogr")
#oeq_global.OeQ_wait_for_renderer(60000)
if not rewritten_layer.isValid():
oeq_global.OeQ_push_warning(title='Write Error!', message='path')
return vlayer
if style != None:
add_style_to_layer(style, rewritten_layer)
rewritten_layer.startEditing()
time.sleep(0.2)
rewritten_layer.commitChanges()
return rewritten_layer
else:
oeq_global.OeQ_push_warning(title='Write Error!', message='path')
return vlayer
def write_vector_layer_to_disk(vlayer, full_path):
"""
Write the given vector layer to disk.
:param vlayer: The vector layer that shall be written to disk
:type vlayer: QgsVectorLayer
:param full_path: The path and filename the layer shall be written to
:type full_path: str
:return:
:rtype:
"""
out_path, out_name = os.path.split(full_path)
if out_name.upper().endswith('.SHP'):
out_name = out_name[:-4]
if vlayer is not None and vlayer.isValid() and os.path.exists(out_path):
if os.path.exists(os.path.join(out_path, out_name + '.shp')):
new_name = out_name
suffix = 0
while os.path.exists(os.path.join(out_path, new_name + '.shp')):
suffix += 1
new_name = out_name + str(suffix)
out_name = new_name
full_path = os.path.join(out_path, out_name + '.shp')
provider = vlayer.dataProvider()
encoding = provider.encoding()
crs = provider.crs()
write_error = QgsVectorFileWriter.writeAsVectorFormat(vlayer, full_path, encoding, crs, 'ESRI Shapefile')
#QgsVectorFileWriter()
if write_error == QgsVectorFileWriter.WriterError:
raise IOError('Can\'t create the file: {0}'.format(full_path))
return None
else:
# wait until the layer was created
timeout = 30
while not os.path.exists(full_path) and timeout:
time.sleep(0.1)
timeout -= 1
# disk_layer = QgsVectorLayer(full_path, out_name, 'ogr')
# if disk_layer.isValid():
# old_features = provider.getFeatures()
# new_provider = disk_layer.dataProvider()
# feature_list = []
# for feature in old_features:
# feature_list.append(feature)
# new_provider.addFeatures(feature_list)
# return disk_layer
# else:
# return None
else:
return None
def __create_backup_file(self, orig_layer):
file_name = self.backup_path + QDir.separator() + self.layer_id
error = QgsVectorFileWriter.writeAsVectorFormat(orig_layer, file_name, "utf-8", None, "ESRI Shapefile",
False, None, list(), list(), True)
if error == QgsVectorFileWriter.NoError:
QgsMessageLog.logMessage(self.plugin.tr('Backup created.'), self.plugin.tr('Vertex Tools'),
QgsMessageLog.INFO)
def nodeVectorSave(node,filepath=None,crs=None,load=False):
from qgis.core import QgsCoordinateReferenceSystem,QgsVectorFileWriter
from qgis.utils import iface
from mole import oeq_global
if oeq_global.isStringOrUnicode(node):
node = nodeByName(node)
if not node: return None
node = node[0]
if not filepath:
filepath=node.layer().source()
if not crs:
crs=node.layer().crs()
else:
crs = QgsCoordinateReferenceSystem(int(crs.split(':')[1]), QgsCoordinateReferenceSystem.EpsgCrsId)
QgsVectorFileWriter.writeAsVectorFormat( node.layer(),filepath,'System',crs,'ESRI Shapefile')
if load:
iface.addVectorLayer(filepath,None, 'ogr')
def _add_vector_layer(self, vector_layer, layer_name, save_style=False):
"""Add a vector layer to the folder.
:param vector_layer: The layer to add.
:type vector_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:param save_style: If we have to save a QML too. Default to False.
:type save_style: bool
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(
self.uri.filePath(layer_name + '.' + self._default_vector_format))
driver_mapping = {
'shp': 'ESRI Shapefile',
'kml': 'KML',
'geojson': 'GeoJSON',
}
QgsVectorFileWriter.writeAsVectorFormat(
vector_layer,
output.absoluteFilePath(),
'utf-8',
QgsCoordinateTransform(), # No tranformation
driver_mapping[self._default_vector_format])
if save_style:
style_path = QFileInfo(self.uri.filePath(layer_name + '.qml'))
vector_layer.saveNamedStyle(style_path.absoluteFilePath())
assert output.exists()
return True, output.baseName()
def test02_SaveAsShapefile(self):
"""Save layer to a shapefile"""
self._testAvailable() or self.skipTest("Not available")
for ignore in [True, False]:
setSettingValue("/qgis/ignoreShapeEncoding", ignore)
# load a shapefile and save it to a new shapefile
layer = self._testLayer(self.fileName)
outfile = self.testDataPath(u"{}{}.shp".format(self.layerName, 1 if ignore else 2), output=True)
QgsVectorFileWriter.writeAsVectorFormat(layer, outfile, "SJIS", layer.crs())
# compare file set
infile = self.testDataPath(self.fileName)
c = compareFileSet(os.path.splitext(infile)[0], os.path.splitext(outfile)[0],
[".shp", ".shx", ".dbf", ".prj", ".cpg"])
#[".dbf", ".cpg"])
self.assertEqual(c, [], "input and output do not match: {}".format(str(c)))
print 'with "ignore..." option = {}...success'.format(ignore)
def accept(self):
"""Do PetaJakarta download and display it in QGIS.
.. versionadded: 3.3
"""
self.save_state()
try:
self.require_directory()
except CanceledImportDialogError:
return
QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
source = (
'https://rem.petajakarta.org/banjir/data/api/v2/rem/flooded')
layer = QgsVectorLayer(source, 'flood', 'ogr', False)
self.time_stamp = time.strftime('%d-%b-%Y %H:%M:%S')
# Now save as shp
name = 'jakarta_flood.shp'
output_directory = self.output_directory.text()
output_prefix = self.filename_prefix.text()
overwrite = self.overwrite_flag.isChecked()
date_stamp_flag = self.include_date_flag.isChecked()
output_base_file_path = self.get_output_base_path(
output_directory,
output_prefix,
date_stamp_flag,
name,
overwrite)
QgsVectorFileWriter.writeAsVectorFormat(
layer, output_base_file_path, 'CP1250', None, 'ESRI Shapefile')
# Get rid of the GeoJSON layer and rather use local shp
del layer
self.copy_style(output_base_file_path)
self.copy_keywords(output_base_file_path)
layer = self.add_flooded_field(output_base_file_path)
# add the layer to the map
registry = QgsMapLayerRegistry.instance()
registry.addMapLayer(layer)
self.disable_busy_cursor()
self.done(QDialog.Accepted)
def copyLayer( path, layer ):
"returns the new layer"
flType = _getFtype(path)
if flType == "ESRI Shapefile":
if os.path.exists(path): QgsVectorFileWriter.deleteShapeFile( path )
error = QgsVectorFileWriter.writeAsVectorFormat(layer, path, "CP1250", None, flType)
else:
if os.path.exists(path): os.remove(path)
error = QgsVectorFileWriter.writeAsVectorFormat(layer, path, "utf-8", None, flType)
if error == QgsVectorFileWriter.NoError:
layer_name = os.path.splitext( os.path.basename( path ))[0]
newlayer = QgsVectorLayer(path, layer_name, "ogr")
if newlayer.isValid(): return newlayer
else: raise Exception("Could not read output")
else:
raise Exception("Could not write output")
def testDateTimeWriteShapefile(self):
"""Check writing date and time fields to an ESRI shapefile."""
ml = QgsVectorLayer(
('Point?crs=epsg:4326&field=id:int&'
'field=date_f:date&field=time_f:time&field=dt_f:datetime'),
'test',
'memory')
assert ml is not None, 'Provider not initialized'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10)))
ft.setAttributes([1, QDate(2014, 3, 5), QTime(13, 45, 22), QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))])
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.shp')
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr')
fields = created_layer.dataProvider().fields()
self.assertEqual(fields.at(fields.indexFromName('date_f')).type(), QVariant.Date)
#shapefiles do not support time types, result should be string
self.assertEqual(fields.at(fields.indexFromName('time_f')).type(), QVariant.String)
#shapefiles do not support datetime types, result should be string
self.assertEqual(fields.at(fields.indexFromName('dt_f')).type(), QVariant.String)
f = created_layer.getFeatures(QgsFeatureRequest()).next()
date_idx = created_layer.fieldNameIndex('date_f')
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5))
time_idx = created_layer.fieldNameIndex('time_f')
#shapefiles do not support time types
assert isinstance(f.attributes()[time_idx], basestring)
self.assertEqual(f.attributes()[time_idx], '13:45:22')
#shapefiles do not support datetime types
datetime_idx = created_layer.fieldNameIndex('dt_f')
assert isinstance(f.attributes()[datetime_idx], basestring)
self.assertEqual(f.attributes()[datetime_idx], QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)).toString("yyyy/MM/dd hh:mm:ss.zzz"))
def export_features(self):
"""
Exportiert die Datenbanklayer als ESRI-Shapefile
:return:
"""
directory = QFileDialog.getExistingDirectory()
if not directory:
return
# Abfrage, ob Daten überschrieben werden sollen, wenn Verzeichnis nicht leer
override = True
if os.listdir(directory):
reply = self.raise_message("dir_not_empty")
if reply == QMessageBox.Yes:
pass
else:
override = False
# Verzeichnis leer oder override = True
if override:
# progress bar
QgsMessageLog.logMessage("Exportiere nach " + directory, "KKG Plugin", QgsMessageLog.INFO)
layers = QgsMapLayerRegistry.instance().mapLayers().values()
progress_message_bar = self.iface.messageBar().createMessage("Exportiere...")
progress = QProgressBar()
progress.setMaximum(len(layers))
progress.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
progress_message_bar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progress_message_bar, self.iface.messageBar().INFO)
# current extent
extent = self.iface.mapCanvas().extent()
for i in range(0, len(layers)):
layer = layers[i]
file_path = directory + "\\" + layer.name()
errors = QgsVectorFileWriter.writeAsVectorFormat(layer,
file_path,
"UTF-8",
None,
"ESRI Shapefile",
filterExtent=extent,
symbologyExport=QgsVectorFileWriter.NoSymbology)
if errors:
QgsMessageLog.logMessage(layer.name() + " konnte nicht geschrieben werden.", "KKG Plugin",
QgsMessageLog.WARNING)
else:
QgsMessageLog.logMessage(layer.name() + " erfolgreich geschrieben", "KKG Plugin",
QgsMessageLog.INFO)
progress.setValue(i + 1)
self.iface.messageBar().clearWidgets()
QgsMessageLog.logMessage("Export abgeschlossen", "KKG Plugin", QgsMessageLog.INFO)
self._create_project_from_export(directory)
def _init_ext_layer(self, geom_str, idx, crs):
"""given non map of feat, init a qgis layer
:map_feat: {geom_string: list_of_feat}
"""
ext = self.ext
driver_name = ext.upper() # might not needed for
layer_name = self._layer_name(geom_str, idx)
# sqlite max connection 64
# if xyz space -> more than 64 vlayer,
# then create new fname
# fname = make_unique_full_path(ext=ext)
fname = make_fixed_full_path(self._layer_fname(), ext=ext)
if geom_str:
geomz = geom_str if geom_str.endswith("Z") else "{}Z".format(
geom_str)
else:
geomz = "NoGeometry"
vlayer = QgsVectorLayer("{geom}?crs={crs}&index=yes".format(geom=geomz,
crs=crs),
layer_name,
"memory") # this should be done in main thread
# QgsVectorFileWriter.writeAsVectorFormat(vlayer, fname, "UTF-8", vlayer.sourceCrs(),
# driver_name)
db_layer_name = self._db_layer_name(geom_str, idx)
options = QgsVectorFileWriter.SaveVectorOptions()
options.fileEncoding = "UTF-8"
options.driverName = driver_name
options.ct = QgsCoordinateTransform(vlayer.sourceCrs(),
vlayer.sourceCrs(),
QgsProject.instance())
options.layerName = db_layer_name
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer # update mode
if hasattr(QgsVectorFileWriter, "writeAsVectorFormatV2"):
err = QgsVectorFileWriter.writeAsVectorFormatV2(
vlayer, fname, vlayer.transformContext(), options)
else:
err = QgsVectorFileWriter.writeAsVectorFormat(
vlayer, fname, options)
if err[0] == QgsVectorFileWriter.ErrCreateDataSource:
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteFile
if hasattr(QgsVectorFileWriter, "writeAsVectorFormatV2"):
err = QgsVectorFileWriter.writeAsVectorFormatV2(
vlayer, fname, vlayer.transformContext(), options)
else:
err = QgsVectorFileWriter.writeAsVectorFormat(
vlayer, fname, options)
if err[0] != QgsVectorFileWriter.NoError:
raise Exception("%s: %s" % err)
self._update_constraint_trigger(fname, db_layer_name)
uri = "%s|layername=%s" % (fname, db_layer_name)
vlayer = QgsVectorLayer(uri, layer_name, "ogr")
self._save_meta_vlayer(vlayer)
return vlayer
def sendOutputFile(self, handler):
format_dict = WFSFormats[self.format]
# read the GML
gml_path = join(self.tempdir, '{}.gml'.format(self.filename))
output_layer = QgsVectorLayer(gml_path, 'qgis_server_wfs_features',
'ogr')
# Temporary file where to write the output
temporary = QTemporaryFile(
join(QDir.tempPath(),
'request-WFS-XXXXXX.{}'.format(format_dict['filenameExt'])))
temporary.open()
output_file = temporary.fileName()
temporary.close()
if output_layer.isValid():
try:
# create save options
options = QgsVectorFileWriter.SaveVectorOptions()
# driver name
options.driverName = format_dict['ogrProvider']
# file encoding
options.fileEncoding = 'utf-8'
# coordinate transformation
if format_dict['forceCRS']:
options.ct = QgsCoordinateTransform(
output_layer.crs(),
QgsCoordinateReferenceSystem(format_dict['forceCRS']),
QgsProject.instance())
# datasource options
if format_dict['ogrDatasourceOptions']:
options.datasourceOptions = format_dict[
'ogrDatasourceOptions']
# write file
if Qgis.QGIS_VERSION_INT >= 31003:
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormatV2(
output_layer, output_file,
QgsProject.instance().transformContext(), options)
else:
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
output_layer, output_file, options)
if write_result != QgsVectorFileWriter.NoError:
handler.appendBody(b'')
self.logger.critical(error_message)
return False
except Exception as e:
handler.appendBody(b'')
self.logger.critical(str(e))
return False
if format_dict['zip']:
# compress files
import zipfile
# noinspection PyBroadException
try:
import zlib # NOQA
compression = zipfile.ZIP_DEFLATED
except Exception:
compression = zipfile.ZIP_STORED
# create the zip file
zip_file_path = join(self.tempdir, '%s.zip' % self.filename)
with zipfile.ZipFile(zip_file_path, 'w') as zf:
# add all files
zf.write(join(
self.tempdir,
'%s.%s' % (self.filename, format_dict['filenameExt'])),
compress_type=compression,
arcname='%s.%s' %
(self.typename, format_dict['filenameExt']))
for e in format_dict['extToZip']:
file_path = join(self.tempdir,
'%s.%s' % (self.filename, e))
if exists(file_path):
zf.write(file_path,
compress_type=compression,
arcname='%s.%s' % (self.typename, e))
zf.close()
f = QFile(zip_file_path)
if f.open(QFile.ReadOnly):
ba = f.readAll()
handler.appendBody(ba)
return True
else:
# return the file created without zip
f = QFile(output_file)
if f.open(QFile.ReadOnly):
ba = f.readAll()
handler.appendBody(ba)
return True
handler.appendBody(b'')
self.logger.critical('Error no output file')
return False
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = TransferLayerFileGdbToGeoPackageDialog()
self.dlg.pushButton.clicked.connect(self.select_output_file)
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Faire une lsite de ce que contient la geobase
list = fiona.listlayers(self.dlg.lineEdit.text())
tmp = self.dlg.lineEdit.text()
filename = tmp.replace(".gdb", "")
gdb = filename + '.gdb'
# progressMessageBar = self.iface.messageBar().createMessage("Doing something boring...")
# progress = self.QProgressBar()
for name in list:
try:
name2 = (name.replace('_', ''))
ce = '{0}'.format(gdb) + '|' + 'layername=' + '{0}'.format(
name)
# faire un layer avec la string
layer = QgsVectorLayer(ce, '{0}'.format(name), 'ogr')
if path.isfile(filename + '.gpkg'):
options = QgsVectorFileWriter.SaveVectorOptions()
# permet de copier plusieurs classe d'entité et table
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer
options.driverName = 'GPKG'
options.layerName = '{0}'.format(name2)
QgsVectorFileWriter.writeAsVectorFormat(
layer, filename, options)
else:
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
# options.layerName = '{0}'.format(name2)
QgsVectorFileWriter.writeAsVectorFormat(
layer, filename, options)
except Exception as e:
continue
self.iface.messageBar().pushMessage("Réussi ! ",
"Le GeoPackage est situé : " +
filename + '.gpkg',
level=Qgis.Success,
duration=10)
pass
def run(self): # pylint: disable=missing-docstring,too-many-locals,too-many-return-statements,too-many-branches,too-many-statements
try:
electorate_geometries, electorate_attributes = self.calculate_new_electorates(
)
except CanceledException:
return False
# we also need a dictionary of meshblock number to all electorate types
meshblock_electorates = {}
electorate_features = []
for electorate_feature_id, attributes in electorate_attributes.items():
if self.isCanceled():
return False
electorate_code = attributes[self.ELECTORATE_CODE]
geometry = electorate_geometries[electorate_feature_id]
meshblocks = attributes[self.MESHBLOCKS]
electorate_type = attributes[self.ELECTORATE_TYPE]
name = attributes[self.ELECTORATE_NAME]
for m in meshblocks:
meshblock_number = m[self.meshblock_number_idx]
if meshblock_number not in meshblock_electorates:
meshblock_electorates[meshblock_number] = {}
meshblock_electorates[meshblock_number][
electorate_type] = electorate_code
if self.isCanceled():
return False
electorate_feature = QgsFeature()
electorate_feature.setGeometry(geometry)
electorate_feature.setAttributes(
[electorate_type, electorate_code, name])
electorate_features.append(electorate_feature)
electorate_layer = QgsVectorLayer(
"Polygon?crs=EPSG:2193&field=type:string(2)&field=code:string&field=name:string",
"source", "memory")
if not electorate_layer.dataProvider().addFeatures(
electorate_features):
return False
if self.isCanceled():
return False
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'electorates'
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteFile
options.feedback = self.feedback
error, self.message = QgsVectorFileWriter.writeAsVectorFormat(
electorate_layer, self.dest_file, options)
if error:
return False
if self.isCanceled():
return False
layer = QgsVectorLayer(
"NoGeometry?field=meshblock_number:int&field=gn_code:string&field=gs_code:string&field=m_code:string",
"source", "memory")
meshblock_features = []
for meshblock_number, electorates in meshblock_electorates.items():
f = QgsFeature()
gn = electorates[self.GN] if self.GN in electorates else NULL
gs = electorates[self.GS] if self.GS in electorates else NULL
m = electorates[self.M] if self.M in electorates else NULL
f.setAttributes([meshblock_number, gn, gs, m])
meshblock_features.append(f)
if self.isCanceled():
return False
layer.dataProvider().addFeatures(meshblock_features)
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'meshblocks'
options.feedback = self.feedback
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer
error, self.message = QgsVectorFileWriter.writeAsVectorFormat(
layer, self.dest_file, options)
if error:
return False
if self.isCanceled():
return False
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'user_log'
options.feedback = self.feedback
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer
error, self.message = QgsVectorFileWriter.writeAsVectorFormat(
self.user_log_layer, self.dest_file, options)
if error:
return False
return True
def completed(self, exception, result=None):
geojson = {"type": "FeatureCollection",
"name": self.lphoto,
"crs": {"type": "name", "properties": {"name": "crs:OGC:1.3:CRS84"}},
"features": self.geoPhotos}
geofile = open(self.plugin_dir + '/tmp.geojson', 'w')
json.dump(geojson, geofile)
geofile.close()
del self.geoPhotos, geojson
try:
for layer in self.canvas.layers():
if layer.publicSource() == self.outputPath:
self.Qpr_inst.instance().removeMapLayer(layer.id())
os.remove(self.outputPath)
except:
pass
self.layerPhotos = QgsVectorLayer(self.outDirectoryPhotosGeoJSON, self.lphoto, "ogr")
QgsVectorFileWriter.writeAsVectorFormat(self.layerPhotos, self.outputPath, "utf-8",
QgsCoordinateReferenceSystem(self.layerPhotos.crs().authid()),
self.extension)
self.layerPhotos_final = QgsVectorLayer(self.outputPath, self.lphoto, "ogr")
# clear temp.geojson file
try:
f = open(self.outDirectoryPhotosGeoJSON, 'r+')
f.truncate(0) # need '0' when using r+
except:
pass
try:
self.layerPhotos_final.loadNamedStyle(self.plugin_dir + "/svg/photos.qml")
except:
title = 'Warning'
msg = 'No geo-tagged images were detected.'
self.showMessage(title, msg, 'Warning')
self.taskPhotos.destroyed()
return
self.layerPhotos_final.setReadOnly(False)
self.layerPhotos_final.reload()
self.layerPhotos_final.triggerRepaint()
try:
xmin = min(self.lon)
ymin = min(self.lat)
xmax = max(self.lon)
ymax = max(self.lat)
self.canvas.zoomToSelected(self.layerPhotos_final)
self.canvas.setExtent(QgsRectangle(xmin, ymin, xmax, ymax))
except:
pass
###########################################
self.dlg.ok.setEnabled(True)
self.dlg.closebutton.setEnabled(True)
self.dlg.toolButtonImport.setEnabled(True)
self.dlg.toolButtonOut.setEnabled(True)
self.clickPhotos.setChecked(True)
noLocationPhotosCounter = self.initphotos - self.truePhotosCount
if self.truePhotosCount == noLocationPhotosCounter == 0 or self.truePhotosCount == 0:
title = 'Import Photos'
msg = 'Import Completed.\n\nDetails:\n No new photos were added.'
self.showMessage(title, msg, 'Information')
self.taskPhotos.destroyed()
return
elif (self.truePhotosCount == self.initphotos) or ((noLocationPhotosCounter + self.truePhotosCount) == self.initphotos):
title = 'Import Photos'
msg = 'Import Completed.\n\nDetails:\n ' + str(
int(self.truePhotosCount)) + ' photo(s) added without error.\n ' + str(
int(noLocationPhotosCounter)) + ' photo(s) skipped (because of missing location).'
self.showMessage(title, msg, 'Information')
self.Qpr_inst.addMapLayers([self.layerPhotos_final])
self.taskPhotos.destroyed()
def launchR2P(self):
"""Ridge to Point conversion"""
layers = self.iface.legendInterface().layers()
# Get index of combo box
selected_line = self.lineComboBox.currentIndex()
selected_dem_layer = self.DEMComboBox.currentIndex()
# Get layer that fit with the combo box index
self.lines_layer = layers[self.list_vect_ind[selected_line]]
self.dem_layer = layers[self.list_rast_ind[selected_dem_layer]]
self.min_dist = self.minLengthBox.value()
self.id_line = self.idLineComboBox.currentText()
self.output_path = self.outputEdit.text()
l_done = []
time = Timer()
time.start()
tmp_path = os.path.dirname(self.lines_layer.source())
# Extract all points of interest (start of line, end of line, peak, pass) from polyline layer
pointPassage, crs, self.dem_layer = passPointSeek(
self.lines_layer, self.id_line, self.dem_layer, tmp_path)
output_filename = os.path.join(os.path.dirname(self.output_path),
r'temp.shp')
QgsVectorFileWriter.writeAsVectorFormat(pointPassage, output_filename,
"utf-8", crs, "ESRI Shapefile")
pointPassage = None
pointPassage = QgsVectorLayer(output_filename, 'pointpassage', "ogr")
print 'R2P: Remove small ridge part'
ids_rem = []
orphans = []
for pt in pointPassage.getFeatures():
pt_id = pt.id()
pt_geom = pt.geometry().asPoint()
pt_x, pt_y = pt_geom
bounding_box_buff = QgsRectangle(pt_x - self.min_dist,
pt_y - self.min_dist,
pt_x + self.min_dist,
pt_y + self.min_dist)
pts_near_it = pointPassage.getFeatures(
QgsFeatureRequest().setFilterRect(bounding_box_buff))
for pt_near in pts_near_it:
pt_near_id = pt_near.id()
if pt_near_id != pt_id:
dist = math.sqrt(
pt_geom.sqrDist(pt_near.geometry().asPoint()))
if dist != 0 and dist < self.min_dist:
pt_Tid = pt.attribute('T_id')
res = pt_Tid.split('p')
l_id1 = res[0]
pt_near_Tid = pt_near.attribute('T_id')
res = pt_near_Tid.split('p')
l_id2 = res[0]
if l_id1 == l_id2 and (
(pt_Tid[-1] == 's' and pt_near_Tid[-1] == 'e') or
(pt_Tid[-1] == 'e' and pt_near_Tid[-1] == 's')):
if pt_id not in ids_rem:
ids_rem.append(pt_id)
if pt_near_id not in ids_rem:
ids_rem.append(pt_near_id)
# if pt_Tid in orphans:
# orphans.remove(pt_Tid)
# if pt_near_Tid in orphans:
# orphans.remove(pt_near_Tid)
BB1 = pt.geometry().buffer(3, 4).boundingBox()
BB2 = pt_near.geometry().buffer(3, 4).boundingBox()
for feat1 in pointPassage.getFeatures(
QgsFeatureRequest(
QgsExpression(
"nature='start' or nature='end'")).
setFilterRect(BB1)):
tid1 = feat1.attribute("T_id")
if feat1.id(
) not in ids_rem and tid1 not in orphans:
orphans.append(tid1)
for feat2 in pointPassage.getFeatures(
QgsFeatureRequest(
QgsExpression(
"nature='start' or nature='end'")).
setFilterRect(BB2)):
tid2 = feat2.attribute("T_id")
if feat2.id(
) not in ids_rem and tid2 not in orphans:
orphans.append(tid2)
pointPassage.startEditing()
pointPassage.dataProvider().deleteFeatures(ids_rem)
pointPassage.commitChanges()
# Find link point between seperate line
print 'R2P: Find link point between seperate line'
already_done = []
geom_to_change = []
for pt in pointPassage.getFeatures():
if pt.attribute('T_id') in orphans:
pt_id = pt.id()
pt_nat = pt.attribute('nature')
if pt_nat == 'end':
pt_nat_opp = 'start'
else:
pt_nat_opp = 'end'
pt_opp_it = None
pt_opp_it = pointPassage.getFeatures(
QgsFeatureRequest(
QgsExpression("L_id = '%s' and nature='%s'" %
(pt.attribute('L_id'), pt_nat_opp))))
pt_opp = next(pt_opp_it)
pt_opp_geom = pt_opp.geometry().asPoint()
pt_opp_buff = pt_opp.geometry().buffer(1, 4).boundingBox()
pt_opp_near_it = pointPassage.getFeatures(
QgsFeatureRequest(
QgsExpression("L_id != '%s'" %
(pt_opp.attribute('L_id')))))
list_opp = [
pt_opp_near.attribute('T_id')
for pt_opp_near in pt_opp_near_it
]
list_opp.append(pt_opp.attribute('T_id'))
pt_geom = pt.geometry().asPoint()
pt_x, pt_y = pt_geom
bounding_box_buff = QgsRectangle(pt_x - self.min_dist * 2,
pt_y - self.min_dist * 2,
pt_x + self.min_dist * 2,
pt_y + self.min_dist * 2)
pts_near_it = pointPassage.getFeatures(
QgsFeatureRequest().setFilterRect(bounding_box_buff))
list_id = []
w0 = 0
id0 = pt_id
act_dist = None
list_line = []
for pt_near in pts_near_it:
pt_near_id = pt_near.id()
pt_near_Tid = pt_near.attribute('T_id')
pt_near_geom = pt_near.geometry().asPoint()
if pt_near_id != pt_id and pt_near_Tid in orphans and pt_near_geom != pt_opp_geom:
dist = math.sqrt(pt_geom.sqrDist(pt_near_geom))
if dist != 0 and dist < self.min_dist * 2:
pt_Tid = pt.attribute('T_id')
res = pt_Tid.split('p')
l_id1 = res[0]
res = pt_near_Tid.split('p')
l_id2 = res[0]
if pt_id not in already_done and l_id1 != l_id2 and l_id2 not in list_line and pt_Tid[
-1] in ['s', 'e'] and pt_near_Tid[-1] in [
's', 'e'
]:
list_id.append(pt_near_id)
list_line.append(l_id2)
w0 += dist
already_done.append(pt_id)
for id in list_id:
point1 = next(
pointPassage.getFeatures(
QgsFeatureRequest().setFilterFid(id)))
point1_geom = point1.geometry().asPoint()
pt1_x, pt1_y = point1_geom
bounding_box_buff1 = QgsRectangle(pt_x - self.min_dist * 2,
pt_y - self.min_dist * 2,
pt_x + self.min_dist * 2,
pt_y + self.min_dist * 2)
pts1_near_it = pointPassage.getFeatures(
QgsFeatureRequest().setFilterRect(bounding_box_buff1))
w = 0
for opoint in pts1_near_it:
if id != opoint.id() and opoint.attribute(
'T_id') in orphans:
opoint_geom = opoint.geometry().asPoint()
p = math.sqrt(point1_geom.sqrDist(opoint_geom))
w += p
if w < w0:
w0 = w
id0 = opoint.id()
already_done.append(id)
list_id.append(pt_id)
try:
list_id.remove(id0)
except ValueError:
continue
change = [id0, list_id]
geom_to_change.append(change)
for change in geom_to_change:
id_fix = change[0]
req = QgsFeatureRequest().setFilterFid(id_fix)
point_fix_it = pointPassage.getFeatures(req)
try:
for point_fix in point_fix_it:
geom_fix = point_fix.geometry()
# try:
# orphans.remove(point_fix.attribute("T_id"))
# except ValueError:
# continue
ids_change = change[1]
for id_change in ids_change:
req = QgsFeatureRequest().setFilterFid(id_change)
point_change_it = pointPassage.getFeatures(req)
point_change = next(point_change_it)
# try:
# orphans.remove(point_change.attribute("T_id"))
# except ValueError:
# continue
pointPassage.startEditing()
pointPassage.dataProvider().changeGeometryValues(
{id_change: geom_fix})
pointPassage.commitChanges()
pointPassage.updateExtents()
except StopIteration:
pass
print 'R2P: Find link point between seperate line'
already_done = []
geom_to_change = []
for pt in pointPassage.getFeatures():
pt_id = pt.id()
pt_geom = pt.geometry().asPoint()
pt_x, pt_y = pt_geom
bounding_box_buff = QgsRectangle(pt_x - self.min_dist,
pt_y - self.min_dist,
pt_x + self.min_dist,
pt_y + self.min_dist)
pts_near_it = pointPassage.getFeatures(
QgsFeatureRequest().setFilterRect(bounding_box_buff))
list_id = []
w0 = 0
id0 = pt_id
for pt_near in pts_near_it:
pt_near_id = pt_near.id()
pt_near_Tid = pt_near.attribute('T_id')
if pt_near_id != pt_id:
dist = math.sqrt(
pt_geom.sqrDist(pt_near.geometry().asPoint()))
if dist != 0 and dist < self.min_dist:
pt_Tid = pt.attribute('T_id')
res = pt_Tid.split('p')
l_id1 = res[0]
res = pt_near_Tid.split('p')
l_id2 = res[0]
if pt_id not in already_done and l_id1 != l_id2 and pt_Tid[
-1] in ['s', 'e'
] and pt_near_Tid[-1] in ['s', 'e']:
list_id.append(pt_near_id)
w0 += dist
already_done.append(pt_id)
for id in list_id:
point1 = next(
pointPassage.getFeatures(
QgsFeatureRequest().setFilterFid(id)))
point1_geom = point1.geometry().asPoint()
pt1_x, pt1_y = point1_geom
bounding_box_buff1 = QgsRectangle(pt_x - self.min_dist,
pt_y - self.min_dist,
pt_x + self.min_dist,
pt_y + self.min_dist)
pts1_near_it = pointPassage.getFeatures(
QgsFeatureRequest().setFilterRect(bounding_box_buff1))
w = 0
for opoint in pts1_near_it:
if id != opoint.id():
opoint_geom = opoint.geometry().asPoint()
p = math.sqrt(point1_geom.sqrDist(opoint_geom))
w += p
if w < w0:
w0 = w
id0 = opoint.id()
already_done.append(id)
list_id.append(pt_id)
try:
list_id.remove(id0)
except ValueError:
continue
change = [id0, list_id]
geom_to_change.append(change)
for change in geom_to_change:
id_fix = change[0]
req = QgsFeatureRequest().setFilterFid(id_fix)
point_fix_it = pointPassage.getFeatures(req)
try:
for point_fix in point_fix_it:
geom_fix = point_fix.geometry()
ids_change = change[1]
for id_change in ids_change:
pointPassage.startEditing()
pointPassage.dataProvider().changeGeometryValues(
{id_change: geom_fix})
pointPassage.commitChanges()
pointPassage.updateExtents()
except StopIteration:
pass
# Remove small ridge part at the end/start of a line
print 'R2P: Remove small ridge part at the end/start of a line'
geom_to_change = []
list_id = []
for pt in pointPassage.getFeatures():
pt_id = pt.id()
pt_geom = pt.geometry().asPoint()
pt_x, pt_y = pt_geom
bounding_box_buff = QgsRectangle(pt_x - self.min_dist,
pt_y - self.min_dist,
pt_x + self.min_dist,
pt_y + self.min_dist)
pts_near_it = pointPassage.getFeatures(
QgsFeatureRequest().setFilterRect(bounding_box_buff))
for pt_near in pts_near_it:
pt_near_id = pt_near.id()
if pt_near_id != pt_id:
dist = math.sqrt(
pt_geom.sqrDist(pt_near.geometry().asPoint()))
if dist != 0 and dist < self.min_dist:
pt_Tid = pt.attribute('T_id')
res = pt_Tid.split('p')
l_id1 = res[0]
pt_near_Tid = pt_near.attribute('T_id')
res = pt_near_Tid.split('p')
l_id2 = res[0]
if l_id1 == l_id2 and pt_Tid[-1] in [
's', 'e'
] and pt_near_Tid[-1] not in [
's', 'e'
] and pt_near_Tid not in list_id:
change = [pt_id, pt_near_id]
list_id.append(pt_near_Tid)
geom_to_change.append(change)
id_rm = []
print 'R2P: geom_to_change: %s' % geom_to_change
for change in geom_to_change:
id_fix = change[0]
req = QgsFeatureRequest().setFilterFid(id_fix)
point_fix_it = pointPassage.getFeatures(req)
point_fix = next(point_fix_it)
try:
id_change = change[1]
req = QgsFeatureRequest().setFilterFid(id_change)
point_ch_it = pointPassage.getFeatures(req)
for point_ch in point_ch_it:
if point_fix.attribute('T_id')[-1] == 'e':
if int(point_ch.attribute('P_id')) < int(
point_fix.attribute('P_id')):
pointPassage.startEditing()
pointPassage.changeAttributeValue(
id_fix, 2, point_ch.attribute('P_id'))
pointPassage.commitChanges()
else:
pointPassage.startEditing()
pointPassage.changeAttributeValue(
id_fix, 2, point_ch.attribute('P_id'))
pointPassage.commitChanges()
id_rm.append(id_change)
except StopIteration:
pass
pointPassage.startEditing()
pointPassage.deleteFeatures(id_rm)
pointPassage.commitChanges()
pointPassage.updateExtents()
# First attempt
print 'R2P: First attempt'
already_done = []
geom_to_change = []
for pt in pointPassage.getFeatures():
pt_id = pt.id()
pt_geom = pt.geometry().asPoint()
pt_x, pt_y = pt_geom
bounding_box_buff = QgsRectangle(pt_x - self.min_dist,
pt_y - self.min_dist,
pt_x + self.min_dist,
pt_y + self.min_dist)
pts_near_it = pointPassage.getFeatures(
QgsFeatureRequest().setFilterRect(bounding_box_buff))
list_id = []
w0 = 0
id0 = pt_id
for pt_near in pts_near_it:
pt_near_id = pt_near.id()
if pt_near_id != pt_id:
dist = math.sqrt(
pt_geom.sqrDist(pt_near.geometry().asPoint()))
if dist != 0 and dist < self.min_dist:
pt_Tid = pt.attribute('T_id')
res = pt_Tid.split('p')
l_id1 = res[0]
pt_near_Tid = pt_near.attribute('T_id')
res = pt_near_Tid.split('p')
l_id2 = res[0]
if pt_id not in already_done and pt_near_id not in already_done and l_id1 == l_id2:
pt1_elev = self.dem_layer.dataProvider().identify(
pt_geom, QgsRaster.IdentifyFormatValue)
pt2_elev = self.dem_layer.dataProvider().identify(
pt_near.geometry().asPoint(),
QgsRaster.IdentifyFormatValue)
already_done.append(pt_id)
already_done.append(pt_near_id)
if pt.attribute(
'T_id')[-1] == 'd' and pt_near.attribute(
'T_id') == 'd':
if pt1_elev > pt2_elev:
change = pt_Tid
else:
change = pt_near_Tid
else:
if pt1_elev < pt2_elev:
change = pt_Tid
else:
change = pt_near_Tid
geom_to_change.append(change)
print 'R2P: geom_to_change: %s' % geom_to_change
for change in geom_to_change:
print 'R2P: change: %s' % change
id_fix = change
req = QgsFeatureRequest().setFilterExpression("T_id = '%s'" %
(id_fix))
point_rm_it = pointPassage.getFeatures(req)
point_rm = point_rm_it.next()
id_rm = point_rm.id()
line_id = point_rm.attribute('L_id')
point_pid = int(point_rm.attribute('P_id'))
nat = point_rm.attribute('nature')
fin = 0
count = 1
found = False
if nat == 'end':
fin = 1
else:
pointPassage.startEditing()
while True:
if found:
point_pid += 1
req = QgsFeatureRequest().setFilterExpression(
"L_id ='%s' and P_id = '%s'" %
(line_id, str(point_pid + count)))
point_nxt_it = pointPassage.getFeatures(req)
found = False
point_nxt = None
try:
point_nxt = next(point_nxt_it)
except StopIteration:
point_nxt = None
continue
if point_nxt != None:
pointPassage.changeAttributeValue(
point_nxt.id(), 2, str(point_pid))
current_id = point_nxt.attribute('T_id')
if current_id[-1] == 'e':
break
print 'R2P: current_id: %s' % current_id
found = True
count = 1
else:
count += 1
found = False
pointPassage.deleteFeatures([id_rm])
pointPassage.commitChanges()
pointPassage.updateExtents()
time.stop()
print 'R2P: Processing Time:'
time.show()
error = QgsVectorFileWriter.writeAsVectorFormat(
pointPassage, self.output_path, "utf-8", crs, "ESRI Shapefile")
if error == QgsVectorFileWriter.NoError:
print "R2P: Success!"
out_layer = self.iface.addVectorLayer(self.output_path, "", "ogr")
if not out_layer:
print "R2P: Layer failed to load!"
def processAlgorithm(self, parameters, context, feedback):
layers = self.parameterAsLayerList(parameters, self.INPUT_DATASOURCES,
context)
query = self.parameterAsString(parameters, self.INPUT_QUERY, context)
uid_field = self.parameterAsString(parameters, self.INPUT_UID_FIELD,
context)
geometry_field = self.parameterAsString(parameters,
self.INPUT_GEOMETRY_FIELD,
context)
geometry_type = self.parameterAsEnum(parameters,
self.INPUT_GEOMETRY_TYPE, context)
geometry_crs = self.parameterAsCrs(parameters, self.INPUT_GEOMETRY_CRS,
context)
df = QgsVirtualLayerDefinition()
for layerIdx, layer in enumerate(layers):
# Issue https://github.com/qgis/QGIS/issues/24041
# When using this algorithm from the graphic modeler, it may try to
# access (thanks the QgsVirtualLayerProvider) to memory layer that
# belongs to temporary QgsMapLayerStore, not project.
# So, we write them to disk is this is the case.
if context.project() and not context.project().mapLayer(
layer.id()):
basename = "memorylayer." + QgsVectorFileWriter.supportedFormatExtensions(
)[0]
tmp_path = QgsProcessingUtils.generateTempFilename(basename)
QgsVectorFileWriter.writeAsVectorFormat(
layer, tmp_path,
layer.dataProvider().encoding())
df.addSource('input{}'.format(layerIdx + 1), tmp_path, "ogr")
else:
df.addSource('input{}'.format(layerIdx + 1), layer.id())
if query == '':
raise QgsProcessingException(
self.
tr('Empty SQL. Please enter valid SQL expression and try again.'
))
localContext = self.createExpressionContext(parameters, context)
expandedQuery = QgsExpression.replaceExpressionText(
query, localContext)
df.setQuery(expandedQuery)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NoGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs.isValid():
df.setGeometrySrid(geometry_crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise QgsProcessingException(
vLayer.dataProvider().error().message())
if vLayer.wkbType() == QgsWkbTypes.Unknown:
raise QgsProcessingException(self.tr("Cannot find geometry field"))
(sink, dest_id) = self.parameterAsSink(
parameters, self.OUTPUT, context, vLayer.fields(),
vLayer.wkbType() if geometry_type != 1 else 1, vLayer.crs())
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
features = vLayer.getFeatures()
total = 100.0 / vLayer.featureCount() if vLayer.featureCount() else 0
for current, inFeat in enumerate(features):
if feedback.isCanceled():
break
sink.addFeature(inFeat, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}
def accept(self, *args, **kwargs):
try:
if not self.validate():
return False
# disable form via a frame, this will still allow interaction with the message bar
# self.fraMain.setDisabled(True)
# clean gui and Qgis messagebars
self.cleanMessageBars(True)
# Change cursor to Wait cursor
QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
self.iface.mainWindow().statusBar().showMessage(
'Processing {}'.format(self.windowTitle()))
LOGGER.info('{st}\nProcessing {}'.format(self.windowTitle(),
st='*' * 50))
self.send_to_messagebar(
"Please wait. QGIS will be locked. See log panel for progress.",
level=Qgis.Warning,
duration=0,
addToLog=False,
core_QGIS=False,
showLogPanel=True)
# Add settings to log
settingsStr = 'Parameters:---------------------------------------'
if self.chkUseSelected.isChecked():
settingsStr += '\n {:20}\t{} with {} selected features'.format(
'Strip points layer:',
self.mcboPointsLayer.currentLayer().name(),
self.mcboPointsLayer.currentLayer().selectedFeatureCount())
else:
settingsStr += '\n {:20}\t{}'.format(
'Strip points layer:',
self.mcboPointsLayer.currentLayer().name())
settingsStr += '\n {:20}\t{}'.format(
'Strip values raster:',
self.mcboRasterLayer.currentLayer().name())
control_file, zone_file = ['', '']
if self.mcboCtrlRasterLayer.currentLayer() is not None:
settingsStr += '\n {:20}\t{}'.format(
'Control values raster:',
self.mcboCtrlRasterLayer.currentLayer().name())
control_file = get_layer_source(
self.mcboCtrlRasterLayer.currentLayer())
if self.mcboZoneRasterLyr.currentLayer() is not None:
settingsStr += '\n {:20}\t{}'.format(
'Control values raster:',
self.mcboZoneRasterLyr.currentLayer().name())
zone_file = get_layer_source(
self.mcboZoneRasterLyr.currentLayer())
settingsStr += '\n {:20}\t{}'.format(
'Moving window size: ', self.dsbMovingWinSize.value())
settingsStr += '\n {:30}\t{}\n'.format(
'Output folder:', self.lneOutputFolder.text())
LOGGER.info(settingsStr)
lyrPoints = self.mcboPointsLayer.currentLayer()
if self.chkUseSelected.isChecked() or lyrPoints.providerType(
) == 'delimitedtext':
savePtsName = lyrPoints.name() + '_strippts.shp'
fileStripPts = os.path.join(TEMPDIR, savePtsName)
if os.path.exists(fileStripPts):
removeFileFromQGIS(fileStripPts)
QgsVectorFileWriter.writeAsVectorFormat(
lyrPoints,
fileStripPts,
"utf-8",
lyrPoints.crs(),
driverName="ESRI Shapefile",
onlySelected=self.chkUseSelected.isChecked())
if self.DISP_TEMP_LAYERS:
addVectorFileToQGIS(fileStripPts,
layer_name=os.path.splitext(
os.path.basename(fileStripPts))[0],
group_layer_name='DEBUG',
atTop=True)
else:
fileStripPts = get_layer_source(lyrPoints)
points_desc = describe.VectorDescribe(fileStripPts)
gdf_pts = points_desc.open_geo_dataframe()
df_table = ttest_analysis(gdf_pts,
points_desc.crs,
get_layer_source(
self.mcboRasterLayer.currentLayer()),
self.lneOutputFolder.text(),
zone_file,
control_file,
size=self.dsbMovingWinSize.value())
self.cleanMessageBars(True)
self.fraMain.setDisabled(False)
self.iface.mainWindow().statusBar().clearMessage()
self.iface.messageBar().popWidget()
QApplication.restoreOverrideCursor()
return super(tTestAnalysisDialog, self).accept(*args, **kwargs)
except Exception as err:
QApplication.restoreOverrideCursor()
self.iface.mainWindow().statusBar().clearMessage()
self.cleanMessageBars(True)
self.fraMain.setDisabled(False)
self.send_to_messagebar(str(err),
level=Qgis.Critical,
duration=0,
addToLog=True,
core_QGIS=False,
showLogPanel=True,
exc_info=sys.exc_info())
return False # leave dialog open
def run(self):
for dlIndex in range(0, self.total_download_count):
url = self.all_urls[dlIndex][0]
url_parts = url.split('/')
file_name = url_parts[-1].split('?')[0]
data_dir_name = self.all_urls[dlIndex][1]
data_dir_name = data_dir_name.replace(":", "_suhde_")
dir_path = os.path.join(self.data_download_dir, data_dir_name)
dir_path = os.path.join(dir_path, file_name.split('.')[0])
data_type = self.all_urls[dlIndex][3]
percentage = dlIndex / float(self.total_download_count) * 100.0
self.setProgress(percentage)
if not os.path.exists(dir_path):
QgsMessageLog.logMessage("Skipping directory: " + dir_path,
'NLSgpkgloader', 1)
continue
for listed_file_name in os.listdir(dir_path):
if data_type == "gml" and listed_file_name.endswith(".xml"):
driver = ogr.GetDriverByName('GML')
data_source = driver.Open(
os.path.join(dir_path, listed_file_name), 0)
layer_count = data_source.GetLayerCount()
mtk_layer_count = 0 # Used for breaking from the for loop when all MTK layers chosen by the user have been added
for i in range(layer_count):
if self.isCanceled():
return False
layer = data_source.GetLayerByIndex(i)
layer_name = layer.GetName()
if layer_name in self.products:
new_layer = QgsVectorLayer(
os.path.join(dir_path, listed_file_name) +
"|layerid=" + str(i), layer_name, "ogr")
if new_layer.isValid():
options = QgsVectorFileWriter.SaveVectorOptions(
)
options.layerName = layer_name
options.driverName = "GPKG"
options.fileEncoding = "UTF-8"
if os.path.isfile(self.gpkg_path):
if QgsVectorLayer(self.gpkg_path +
"|layername=" +
layer_name).isValid():
options.actionOnExistingFile = QgsVectorFileWriter.AppendToLayerNoNewFields
else:
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer
else:
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteFile
e = QgsVectorFileWriter.writeAsVectorFormat(
new_layer, self.gpkg_path, options)
if e[0]:
QgsMessageLog.logMessage(
"Failed to write layer " + layer_name +
" to geopackage", 'NLSgpkgloader', 2)
break
mtk_layer_count += 1
else:
# TODO: handle invalid layer error
#QgsMessageLog.logMessage("Invalid layer: " + listed_file_name + ":" layer_name, 'NLSgpkgloader', 2)
pass
if mtk_layer_count == len(self.products):
break
else:
QgsMessageLog.logMessage(
"cannot add the data type " + data_type +
", listed_file_name: " + listed_file_name,
'NLSgpkgloader', 0)
return True
def buildLayer(self):
displayName = self.database.name + '_' + self.project.name + '_' + self.shapeName.replace(
'/', '')
vectorLayer = QgsVectorLayer("Point", displayName, "memory")
provider = vectorLayer.dataProvider()
vectorLayer.startEditing()
# create field names for vector layer
attributeList = [
QgsField("INVID", QVariant.String),
QgsField("SHORTNAME", QVariant.String),
QgsField("LONGNAME", QVariant.String),
QgsField("XCOORD", QVariant.Double),
QgsField("YCOORD", QVariant.Double),
QgsField("DBTYPE", QVariant.String),
QgsField("DATABASE", QVariant.String),
QgsField("PRJNAME", QVariant.String),
QgsField("PRJID", QVariant.String),
QgsField("OBJECTTYPE", QVariant.String),
QgsField("EPSG", QVariant.Int)
]
for key in self.objects[0].data.keys():
try:
value = float(self.objects[0].data[key])
field = QgsField(key, QVariant.Double)
attributeList.append(field)
except:
pass
try:
value = str(self.objects[0].data[key])
field = QgsField(key, QVariant.String)
attributeList.append(field)
except:
pass
# add fields to attribute table
provider.addAttributes(attributeList)
epsg = 0
for object in self.objects:
epsg = object.epsg
# add feature
feat = QgsFeature()
if object.coordinates[0] == None or object.coordinates[1] == None:
continue
#print object.coordinates[0], float(object.coordinates[0]), object.coordinates[1], float(object.coordinates[1])
feat.setGeometry(
QgsGeometry.fromPoint(
QgsPoint(object.coordinates[0], object.coordinates[1])))
attribute = [
object.invid, object.shortname, object.name,
float(object.coordinates[0]),
float(object.coordinates[1]),
self.database.options["connection"], self.database.filepath,
object.parent.name, object.parent.id, object.locname,
object.epsg
]
for key in object.data.keys():
if isinstance(object.data[key], decimal.Decimal):
attribute.append(float(object.data[key]))
else:
attribute.append(object.data[key])
feat.setAttributes(attribute)
provider.addFeatures([feat])
# Commit changes
vectorLayer.commitChanges()
#http://qgis.org/api/2.18/classQgsVectorFileWriter.html#ab566ed2016352c37d9a4a6900614eac2
error = ""
#fileName = displayName.replace('\\','').replace(':','').replace('*','').replace('?','').replace('"','').replace('<','').replace('>','').replace('|','').replace('/','').strip().replace(' ','_')
#generating random string for filename
fileName = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(20))
CoordinateReferenceSystem = QgsCoordinateReferenceSystem(
4326, QgsCoordinateReferenceSystem.EpsgCrsId)
if epsg:
CoordinateReferenceSystem = QgsCoordinateReferenceSystem(
epsg, QgsCoordinateReferenceSystem.EpsgCrsId)
if self.main.config.get("Options", "savelayer") == "True":
fileName = os.path.join(self.main.tmpDirectory,
fileName + '.sqlite')
error = QgsVectorFileWriter.writeAsVectorFormat(
vectorLayer, fileName, 'CP1250', CoordinateReferenceSystem,
'SpatiaLite', False, None, ['SPATIALITE=YES'])
layer = QgsVectorLayer(fileName, displayName, "ogr")
layer.setCrs(CoordinateReferenceSystem)
else:
fileName = os.path.join(self.main.tmpDirectory, fileName + '.shp')
#error = QgsVectorFileWriter.writeAsVectorFormat(vectorLayer, fileName, 'utf-8', CoordinateReferenceSystem, 'ESRI Shapefile')
error = QgsVectorFileWriter.writeAsVectorFormat(
vectorLayer, fileName, 'CP1250', CoordinateReferenceSystem,
'ESRI Shapefile')
layer = QgsVectorLayer(fileName, displayName, "ogr")
layer.setCrs(CoordinateReferenceSystem)
if error == QgsVectorFileWriter.NoError:
print("NoError ")
QgsProject.instance().addMapLayer(layer)
elif error == QgsVectorFileWriter.ErrDriverNotFound:
print("ErrDriverNotFound ")
elif error == QgsVectorFileWriter.ErrCreateDataSource:
QApplication.restoreOverrideCursor()
QMessageBox.critical(QWidget(), "Error", "ErrCreateDataSource")
print("ErrCreateDataSource ")
elif error == QgsVectorFileWriter.ErrCreateLayer:
print("ErrCreateLayer ")
elif error == QgsVectorFileWriter.ErrAttributeTypeUnsupported:
print("ErrAttributeTypeUnsupported ")
elif error == QgsVectorFileWriter.ErrAttributeCreationFailed:
print("ErrAttributeCreationFailed ")
elif error == QgsVectorFileWriter.ErrProjection:
print("ErrProjection ")
elif error == QgsVectorFileWriter.ErrFeatureWriteFailed:
print("ErrFeatureWriteFailed ")
elif error == QgsVectorFileWriter.ErrInvalidLayer:
print("ErrInvalidLayer ")
elif error == QgsVectorFileWriter.Canceled:
QApplication.restoreOverrideCursor()
QMessageBox.critical(
QWidget(), "Error",
"Writing was interrupted by manual cancelation.")
print("Canceled ")
def accept(self):
"""Do PetaBencana download and display it in QGIS.
.. versionadded: 3.3
"""
self.save_state()
try:
self.require_directory()
except CanceledImportDialogError:
return
QtGui.qApp.setOverrideCursor(QtGui.QCursor(QtCore.Qt.WaitCursor))
source = self.define_url()
# save the file as json first
name = 'jakarta_flood.json'
output_directory = self.output_directory.text()
output_prefix = self.filename_prefix.text()
overwrite = self.overwrite_flag.isChecked()
date_stamp_flag = self.include_date_flag.isChecked()
output_base_file_path = self.get_output_base_path(
output_directory,
output_prefix,
date_stamp_flag,
name,
overwrite)
title = self.tr("Can't access API")
try:
self.download(source, output_base_file_path)
# Open downloaded file as QgsMapLayer
layer = QgsVectorLayer(
output_base_file_path, 'flood', 'ogr', False)
except Exception as e:
disable_busy_cursor()
QMessageBox.critical(self, title, str(e))
return
self.time_stamp = time.strftime('%d-%b-%Y %H:%M:%S')
# Now save as shp
name = 'jakarta_flood.shp'
output_base_file_path = self.get_output_base_path(
output_directory,
output_prefix,
date_stamp_flag,
name,
overwrite)
QgsVectorFileWriter.writeAsVectorFormat(
layer, output_base_file_path, 'CP1250', None, 'ESRI Shapefile')
# Get rid of the GeoJSON layer and rather use local shp
del layer
self.copy_style(output_base_file_path)
self.copy_keywords(output_base_file_path)
layer = self.add_flooded_field(output_base_file_path)
# check if the layer has feature or not
if layer.featureCount() <= 0:
city = self.city_combo_box.currentText()
message = self.tr(
'There are no floods data available on {city} '
'at this time.').format(city=city)
display_warning_message_box(
self,
self.tr('No data'),
message)
disable_busy_cursor()
else:
# add the layer to the map
registry = QgsMapLayerRegistry.instance()
registry.addMapLayer(layer)
disable_busy_cursor()
self.done(QDialog.Accepted)
def completed(self, exception, result=None):
geojson = {"type": "FeatureCollection",
"name": self.myPhoto,
"crs": {"type": "name", "properties": {"name": "crs:OGC:1.3:CRS84"}},
"features": self.geoPhotos}
geofile = open(self.outDirectoryPhotosGeoJSON, 'w')#temp.geojson
json.dump(geojson, geofile) #write file geojson to geofile
geofile.close()
del self.geoPhotos, geojson
try:
for layer in self.canvas.layers():
if layer.publicSource() == self.outputPath:
self.Qpr_inst.instance().removeMapLayer(layer.id())
os.remove(self.outputPath)
except:
pass
#เก็บข้อมูลรูปภาพเป็น layer เป็นลักษณะ vecter file format
self.layerPhotos = QgsVectorLayer(self.outDirectoryPhotosGeoJSON, self.myPhoto, "ogr")
QgsVectorFileWriter.writeAsVectorFormat(self.layerPhotos, self.outputPath, "utf-8",
QgsCoordinateReferenceSystem(self.layerPhotos.crs().authid()),
self.extension)
self.layerPhotos_final = QgsVectorLayer(self.outputPath, self.myPhoto, "ogr")
# clear temp.geojson file
try:
f = open(self.outDirectoryPhotosGeoJSON, 'r+')
f.truncate(0) # need '0' when using r+
except:
pass
self.layerPhotos_final.setReadOnly(False)
self.layerPhotos_final.reload()
self.layerPhotos_final.triggerRepaint()
try:
xmin = min(self.lon)
ymin = min(self.lat)
xmax = max(self.lon)
ymax = max(self.lat)
self.canvas.zoomToSelected(self.layerPhotos_final)#ซูมจุด vector
self.canvas.setExtent(QgsRectangle(xmin, ymin, xmax, ymax))#Sets the extent of the map canvas to the specified rectangle.
except:
pass
###########################################
self.dlg.ok.setEnabled(True)
self.dlg.closebutton.setEnabled(True)
self.dlg.toolButtonImport.setEnabled(True)
self.dlg.toolButtonOut.setEnabled(True)
noLocationPhotosCounter = self.initphotos - self.truePhotosCount - self.out_of_extent_photos
if (self.truePhotosCount == noLocationPhotosCounter == 0 or self.truePhotosCount == 0 ) and self.showMessageHide:
title = 'Import Photos'
msg = 'Import Completed.\n\nDetails:\n No new photos were added.'
self.showMessage(title, msg, 'Information')
self.taskPhotos.destroyed()
return
elif ((self.truePhotosCount == self.initphotos) or ((noLocationPhotosCounter + self.truePhotosCount + self.out_of_extent_photos) == self.initphotos) )and self.showMessageHide:
title = 'Import Photos'
msg = 'Import Completed.\n\nDetails:\n ' + str(
int(self.truePhotosCount)) + ' photo(s) added without error.\n ' + str(
int(noLocationPhotosCounter)) + ' photo(s) skipped (because of missing location).\n '
self.showMessage(title, msg, 'Information')
#add layer photo เป็นลำดับในลักษณะ Tree
g = self.Qpr_inst.layerTreeRoot().insertGroup(0, self.myPhoto)
self.Qpr_inst.addMapLayer(self.layerPhotos_final, False)#Add a layer to the map of loaded layers.
nn = QgsLayerTreeLayer(self.layerPhotos_final)
g.insertChildNode(0, nn)
def runAndCreateLayer(parent):
geomDialog = QgsNewVectorLayerDialog(parent)
if (geomDialog.exec_() == QDialog.Rejected):
return ""
geometrytype = geomDialog.selectedType()
fileformat = geomDialog.selectedFileFormat()
enc = geomDialog.selectedFileEncoding()
crsId = geomDialog.selectedCrsId()
print(QString("New file format will be: %1").arg(fileformat))
attributes = dict()
geomDialog.attributes(attributes)
settings = QSettings()
lastUsedDir = settings.value("/UI/lastVectorFileFilterDir",
QDir.homePath()).toString()
filterString = QgsVectorFileWriter.filterForDriver(fileformat)
fileName = QFileDialog.getSaveFileName(parent, "Save layer as...",
lastUsedDir, filterString)
if (fileName.isNull()):
return ""
if (fileformat == "ESRI Shapefile"
and not fileName.endsWith(".shp", Qt.CaseInsensitive)):
fileName += ".shp"
settings.setValue("/UI/lastVectorFileFilterDir",
QFileInfo(fileName).absolutePath())
settings.setValue("/UI/encoding", enc)
#try to create the new layer with OGRProvider instead of QgsVectorFileWriter
pReg = QgsProviderRegistry.instance()
ogrlib = pReg.library("ogr")
# load the data provider
myLib = QLibrary(ogrlib)
loaded = myLib.load()
constructionLineLayer = None
mapUnits = define._canvas.mapUnits()
layerName = String.QString2Str(fileName).split("\\")[-1]
path = "memory"
selectedCrs = geomDialog.selectedCrs()
if geometrytype == QGis.Line:
# if mapUnits == QGis.Meters:
constructionLineLayer = QgsVectorLayer(
"linestring?crs=%s" % selectedCrs.authid(), layerName, path)
# else:
# constructionLineLayer = QgsVectorLayer("linestring?crs=%s"%define._latLonCrs.authid (), layerName, path)
elif geometrytype == QGis.Polygon:
# if mapUnits == QGis.Meters:
constructionLineLayer = QgsVectorLayer(
"polygon?crs=%s" % selectedCrs.authid(), layerName, path)
# else:
# constructionLineLayer = QgsVectorLayer("polygon?crs=%s"%define._latLonCrs.authid (), layerName, path)
elif geometrytype == QGis.Point:
# if mapUnits == QGis.Meters:
constructionLineLayer = QgsVectorLayer(
"Point?crs=%s" % selectedCrs.authid(), layerName, path)
# else:
# constructionLineLayer = QgsVectorLayer("Point?crs=%s"%define._latLonCrs.authid (), layerName, path)
fieldList = []
for key in attributes.iterkeys():
fieldList.append(QgsField(key, attributes[key][0]))
constructionLineLayer.startEditing()
constructionLineLayer.dataProvider().addAttributes(fieldList)
constructionLineLayer.commitChanges()
er = QgsVectorFileWriter.writeAsVectorFormat(
constructionLineLayer, fileName, "utf-8",
constructionLineLayer.crs())
constructionLineLayer = QgsVectorLayer(fileName, layerName, "ogr")
QgisHelper.appendToCanvas(define._canvas, [constructionLineLayer],
"NewLayers")
# if ( loaded ):
# print( "ogr provider loaded" )
#
# typedef bool ( *createEmptyDataSourceProc )( const QString&, const QString&, const QString&, QGis::WkbType,
# const QList< QPair<QString, QString> >&, const QgsCoordinateReferenceSystem * )
# createEmptyDataSourceProc createEmptyDataSource = ( createEmptyDataSourceProc ) cast_to_fptr( myLib.resolve( "createEmptyDataSource" ) )
# if ( createEmptyDataSource )
# {
# if ( geometrytype not = QGis::WKBUnknown )
# {
# QgsCoordinateReferenceSystem srs = QgsCRSCache::instance().crsBySrsId( crsId )
# if ( not createEmptyDataSource( fileName, fileformat, enc, geometrytype, attributes, &srs ) )
# {
# return QString::null
# }
# }
# else
# {
# QgsDebugMsg( "geometry type not recognised" )
# return QString::null
# }
# }
# else
# {
# QgsDebugMsg( "Resolving newEmptyDataSource(...) failed" )
# return QString::null
# }
# }
#
# if ( pEnc )
# *pEnc = enc
return fileName
def run(self):
"""Run method that performs all the real work"""
#carrega camadas no combobox
self.populate()
# exibe a caixa de dialogo
self.dlg.show()
# carrega a caixa de dialogo em loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
tic = timeit.default_timer()
# Obtem todas as camadas validas no projeto
point_layers = []
layers = QgsMapLayerRegistry.instance().mapLayers()
for name, layer in layers.iteritems():
# Verifica o tipo da camada selecionada (0 for points, 1 for lines, and 2 for polygons)
if type(layer) == QgsVectorLayer and layer.geometryType() == 0:
point_layers.append(layer)
# Verifica se exite camadas de pontos carregadas
if self.dlg.layerInputMode.isChecked():
if len(point_layers) == 0:
self.showMessage(
self.
tr('Nenhuma camada disponivel. Adicione uma camada do tipo pontos ao projeto.'
), QgsMessageBar.WARNING)
return
# Obtem o nome da camada selecionada
layer_name = self.dlg.layersInput.currentText()
inputLayer = QgsMapLayerRegistry.instance().mapLayersByName(
layer_name)[0]
# Verifica se o SRC eh WGS84 (EPSG:4326)
if inputLayer.crs().authid() != u'EPSG:4326':
self.showMessage(
self.
tr('A camada selecionada deve estar em coordenadas geograficas (WGS 84, EPSG 4326).'
), QgsMessageBar.WARNING)
return
# Verifica se foi definido um caminho para o arquivo de saida
elif (self.dlg.fileOutput.isChecked()
and self.dlg.outputFileName.text() == ''):
self.showMessage(
self.tr('Erro, nao foi definido um arquivo de saida.'),
QgsMessageBar.WARNING)
return
# Retorna a camada de saida
if self.dlg.fileOutput.isChecked():
shapefilename = self.dlg.outputFileName.text()
# Restringir somente para feicoes selecionadas
if self.dlg.layerInputMode.isChecked():
if inputLayer.selectedFeatures():
features = inputLayer.selectedFeatures()
else:
features = inputLayer.getFeatures()
outputName = inputLayer.name()
crsString = inputLayer.crs().authid()
else:
outputName = "Grade_Regular"
crsString = "EPSG:4326"
# Criar camada na memoria para os dados de saida
outputLayer = QgsVectorLayer(
"Point?crs=" + crsString +
"&field=id:integer&field=name:string(20)&field=x:double(20)&field=y:double(20)&field=elev:double(20)&index=yes",
"GetElevation_" + outputName, "memory")
pr = outputLayer.dataProvider()
outFeat = QgsFeature()
# Obtem a lista de pontos para processamento
points = []
if self.dlg.layerInputMode.isChecked():
for feature in features:
points.append(feature.geometry().asPoint())
elif self.dlg.extentInputMode.isChecked():
xmin = self.dlg.extentInputW.text()
xmax = self.dlg.extentInputL.text()
ymin = self.dlg.extentInputS.text()
ymax = self.dlg.extentInputN.text()
interval = self.dlg.extentInputInterval.text()
points = self.get_points_by_extent(xmin, xmax, ymin, ymax,
interval)
# Prepara a barra de progresso
progressMessageBar = self.iface.messageBar()
progress = QProgressBar()
progress.setMaximum(100)
progressMessageBar.pushWidget(progress)
lines_total = len(points) - 1
print("Iniciando a consulta da elevacao de um total de " +
str(lines_total) + " pontos.")
print(points)
# Cria os pontos
i = 1
for point in points:
x = point[0]
y = point[1]
z = self.get_elevation(x, y)
print(str(i) + " => " + str(x) + ", " + str(y) + ", " + str(z))
# Cria o ponto
thePoint = QgsPoint(x, y)
point = QgsGeometry.fromPoint(thePoint)
outFeat.setGeometry(point)
# Adiciona os atributos ao ponto
outFeat.setAttributes([i, 'ponto ' + str(i), x, y, z])
pr.addFeatures([outFeat])
# Set progress
percent = (i / float(lines_total)) * 100
progress.setValue(percent)
i = i + 1
# Redefine a barra de progresso
self.iface.messageBar().clearWidgets()
toc = timeit.default_timer()
# Salva o arquivo na memoria ou em arquivo
if self.dlg.memoryOutput.isChecked(
): # Load memory layer in canvas
QgsMapLayerRegistry.instance().addMapLayer(outputLayer)
elif self.dlg.fileOutput.isChecked(): # Save shapefile
QgsVectorFileWriter.writeAsVectorFormat(
outputLayer, shapefilename, "utf-8", None,
"ESRI Shapefile")
#exibe amensagem de concluido e fecha a janela
self.showMessage(self.tr('Concluido!'), QgsMessageBar.SUCCESS)
self.dlg.close()
pass
def run(self):
print ("paso por el run")
#coloco el puntero arriba del todo
QgsProject.instance().layerTreeRegistryBridge().setLayerInsertionPoint( QgsProject.instance().layerTreeRoot(), 0 )
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
#self.dlg = SilvilidarDialog()
#la siguiente linea inicia el boton de cargar carpetas, peta al cerrar el qgis, deberia poner algun close o algo
#self.dlg.pushButton_select_path.clicked.connect(self.select_laz_folder)
#print("inicio el boton en el gui")
#self.dlg.pushButton_select_path.setEnabled(True)
#print ("pone le boton como habiltado")
# show the dialog
self.dlg.show()
#self.dlg.pushButton_select_path.clicked.connect(self.select_laz_folder)
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
nombre=self.dlg.nombrearchivo_entrada.text().replace(' ','_')##displayText()
usuario=QgsExpressionContextUtils.globalScope().variable('user_account_name')
puertos=["usb:","COM1","COM2","COM3","COM4","COM5","COM6","COM7"]
instalacion=QgsApplication.prefixPath()[:-14]
iface.messageBar().pushMessage("ATENCION", "POR FAVOR, ESPERE", duration=10)
#HAY QUE COMPROBAR QUE HAY ALGO SELECCIONADO, SI NO NO HACE NADA
names=[]
abreviaturas=[]
if self.dlg.checkBox_1.isChecked():
names.append("waypoint")
abreviaturas.append("-w")
if self.dlg.checkBox_2.isChecked():
names.append("track")
abreviaturas.append("-t")
if self.dlg.checkBox_3.isChecked():
names.append("route")
abreviaturas.append("-r")
dest_crs = QgsCoordinateReferenceSystem(25830)
print ("hasta aqui bien")
#aqui habra que comprobar que names tiene algo y si no mostrar un texto al usuario
if len(names)>0:
print (nombre)
path = r'C:/sigmena/gps/'+nombre+'.gpx'
ruta=path
print (ruta)
for puerto in puertos:
for abreviatura in abreviaturas:
#comando='"C:/Program Files/QGIS 3.10/bin/gpsbabel.exe"'+' '+ abreviatura +' -i garmin -f '+ puerto +' -o gpx -F ' + ruta
comando='"'+instalacion+'/bin/gpsbabel.exe"'+' '+ abreviatura +' -i garmin -f '+ puerto +' -o gpx -F ' + ruta
print (comando)
#print (comando)
result = subprocess.Popen(comando, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output,error = result.communicate()
print("en 1")
print (output)
print (error)
for name in names:
vectorLyr =QgsVectorLayer(path+"?type="+name, name, "gpx")
QgsVectorFileWriter.writeAsVectorFormat(vectorLyr,str(path[:-4])+"_"+name,"utf-8",dest_crs,"ESRI Shapefile")
iface.addVectorLayer(str(path[:-4])+"_"+name+".shp", str(nombre)+"_"+name, "ogr")
rutasgps=["D:/Garmin/GPX",r"E:/Garmin/GPX",r"F:/Garmin/GPX",r"H:/Garmin/GPX",r"C:/Garmin/GPX"]
for rutagps in rutasgps:
if os.path.isdir(rutagps):
try:
import glob
listaarchivosengps=glob.glob(rutagps+"*.gpx")
for arch in listaarchivosengps:
shutil.copy2(arch, ruta)
except:
pass
#empieza la carga
if self.dlg.checkBox_4.isChecked():
print("subir archivo punto")
#lo mejor sera solo los elementos selecionados. si no hay ninguno seleccionado usar todos. si no tiene columna name crearla y poner una columna para el nombre.
#ahora mismo si no tienen nombre, al menos los tracks, los llama track0 y los sobreescribe.
#nombre de la capa selecionada
vl2=iface.activeLayer()
nombre= vl2.source()
if vl2 is None:
iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10)
if vl2.wkbType()==4:
print("convertir en puntos")
params={'MULTIPOINTS':nombre,'POINTS':'TEMPORARY_OUTPUT'}
results0=processing.run("saga:convertmultipointstopoints", params)
shapefile = results0['POINTS']
print ("shapefile")
print (shapefile)
if vl2.wkbType()== 1:
print(nombre)
shapefile=nombre
else:
iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de puntos", duration=10)
if vl2.wkbType()== 1 or vl2.wkbType()== 4:
#tendria que mirar si tiene src, si no lo tiene ponerle el del proyecto
#vectorLyr.setCrs(mycrs,True)
#deberia enviar solo los seleccionados
#deberia selecionar la columna con el nombre
params= {'INPUT':shapefile,'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),'OUTPUT':str(shapefile[:-4])+"_wgs84.shp"}
processing.run("native:reprojectlayer",params)
#iface.addVectorLayer(shapefile, nombre [0], "ogr")
#dest_crs = QgsCoordinateReferenceSystem(4326)
#QgsVectorFileWriter.writeAsVectorFormat(vectorLyr,str(shapefile[:-4])+"_wgs84","utf-8",dest_crs,"ESRI Shapefile")
#vectorLyr2 =QgsVectorLayer(str(shapefile[:-4])+"_wgs84.shp", nombre [0]+"_wgs84", "ogr")
#vectorLyr2.setCrs(dest_crs,True)
#iface.addVectorLayer(str(shapefile[:-4])+"_wgs84.shp", str(nombre[0])+"_wgs84", "ogr")
if os.path.exists(str(shapefile[:-4])+".gpx"):
os.remove(str(shapefile[:-4])+".gpx")
comando='"'+instalacion+'/bin/ogr2ogr.exe" -f GPX '+str(shapefile[:-4])+".gpx "+str(shapefile[:-4])+"_wgs84.shp"# -sql SELECT nombre AS name"#ogr2ogr -f GPX output.gpx input.gpx waypoints routes tracks"
print(comando)
os.system(comando)
ruta =str(shapefile[:-4])+".gpx"
#metodo sencillo de ejecutar comando
#comando= os.path.join(r"C:\Users",usuario,r"AppData/Roaming/QGIS/QGIS3/profiles/default/python/plugins/gpsDescargaCarga/cmdbabel/cargagps.bat")
#os.system(comando+" "+ ruta)
for puerto in puertos:
#comando='"C:/Program Files/QGIS 3.10/bin/gpsbabel.exe" -w -i gpx -f '+ruta+' -o garmin -F ' + puerto
comando='"'+instalacion+'/bin/gpsbabel.exe" -w -i gpx -f '+ruta+' -o garmin -F ' + puerto
result = subprocess.Popen(comando, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output,error = result.communicate()
print (output)
print (error)
#rutagps =r"D:\Garmin\GPX"#deberia intentar en varias rutasd, e , f, g, h si existen.
rutasgps=["D:/Garmin/GPX",r"E:/Garmin/GPX",r"F:/Garmin/GPX",r"H:/Garmin/GPX",r"C:/Garmin/GPX"]
for rutagps in rutasgps:
if os.path.isdir(rutagps):
try:
shutil.copy2(ruta, rutagps)
except:
pass
if self.dlg.checkBox_5.isChecked():
print("subir archivo linea")
#lo mejor sera solo los elementos selecionados. si no hay ninguno seleccionado usar todos. si no tiene columna name crearla y poner una columna para el nombre.
#nombre de la capa selecionada
vl2=iface.activeLayer()
nombre= vl2.source()
if vl2 is None:
iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de lineas o poligonos", duration=10)
#CONVIERTO DE POLIGONOS A LINEAS
if vl2.wkbType()== 6:
#elimina la barra si la hay
if '|' in nombre:
nombre = nombre [:nombre.rfind('|')]
"""
params={'INPUT':nombre,'OUTPUT':'TEMPORARY_OUTPUT'}
results0=processing.run("native:polygonstolines", params)
nombre = results0['OUTPUT']
shapefile = results0['OUTPUT']
print ("shapefile")
print (shapefile)
print("paso por pol2lin ok")
"""
params={'POLYGONS':nombre, 'EDGES':'TEMPORARY_OUTPUT','NODES':'TEMPORARY_OUTPUT' }
results0=processing.run("saga:polygonstoedgesandnodes", params)
nombre = results0['EDGES']
shapefile = results0['EDGES']
print ("shapefile")
print (shapefile)
#se podria convertir polilineas en lineas y poligonos en lineas tambien.
if vl2.wkbType()== 5:
#elimina la barra si la hay
if '|' in nombre:
nombre = nombre [:nombre.rfind('|')]
shapefile=nombre
else:
iface.messageBar().pushMessage("ATENCION", "Selecciona una capa de lineas o poligonos", duration=10)
if vl2.wkbType()== 5 or vl2.wkbType()== 6:#o poligono o polilinea or vl2.wkbType()== 3:
#tendria que mirar si tiene src, si no lo tiene ponerle el del proyecto
#vectorLyr.setCrs(mycrs,True)
params= {'INPUT':shapefile,'TARGET_CRS':QgsCoordinateReferenceSystem('EPSG:4326'),'OUTPUT':str(shapefile[:-4])+"_wgs84.shp"}
processing.run("native:reprojectlayer",params)
if os.path.exists(str(shapefile[:-4])+".gpx"):
os.remove(str(shapefile[:-4])+".gpx")
#processing.run("gdal:convertformat", {'INPUT':shapefile,'OPTIONS':"'FORCE_GPX_TRACK:YES','GPX_USE_EXTENSIONS: YES'",'OUTPUT':str(shapefile[:-4])+".gpx"})
#iface.addVectorLayer(shapefile, nombre [0], "ogr")
comando='"'+instalacion+'/bin/ogr2ogr.exe" -f GPX '+str(shapefile[:-4])+".gpx "+str(shapefile[:-4])+"_wgs84.shp"+" -dsco GPX_USE_EXTENSIONS=YES -lco FORCE_GPX_TRACK=YES"
#comando="ogr2ogr -f GPX GPX_USE_EXTENSIONS=YES GPX_USE_EXTENSIONS=YES "+str(shapefile[:-4])+".gpx "+str(shapefile[:-4])+"_wgs84.shp"# -sql SELECT nombre AS name"#ogr2ogr -f GPX output.gpx input.gpx waypoints routes tracks"
os.system(comando)
ruta =str(shapefile[:-4])+".gpx"
#comando= os.path.join(r"C:\Users",usuario,r"AppData/Roaming/QGIS/QGIS3/profiles/default/python/plugins/gpsDescargaCarga/cmdbabel/cargagps.bat")
#os.system(comando+" "+ ruta)
for puerto in puertos:
comando='"'+instalacion+'/bin/gpsbabel.exe" -t -i gpx -f '+ruta+' -o garmin -F ' + puerto
result = subprocess.Popen(comando, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output,error = result.communicate()
print (output)
print (error)
#rutagps =r"D:\Garmin\GPX"
rutasgps=["D:/Garmin/GPX","E:/Garmin/GPX","F:/Garmin/GPX","H:/Garmin/GPX","C:/Garmin/GPX"]
for rutagps in rutasgps:
if os.path.isdir(rutagps):
try:
shutil.copy2(ruta, rutagps)
except:
pass
else:
pass
def save_hazard_data(self):
if self.dummy_report_folder:
filename = os.path.join(self.working_dir, self.dummy_report_folder,
'flood_data.json')
hazard_geojson = DummySourceAPI.get_aggregate_report(filename)
else:
hazard_geojson = PetaJakartaAPI.get_aggregate_report(
self.duration, self.level)
if not hazard_geojson:
raise PetaJakartaAPIError("Can't access PetaJakarta REST API")
with open(self.hazard_path, 'w+') as f:
f.write(hazard_geojson)
# Save the layer as shp
file_info = QFileInfo(self.hazard_path)
hazard_layer = QgsVectorLayer(self.hazard_path, file_info.baseName(),
'ogr', False)
target_name = 'flood_data.shp'
self.hazard_path = os.path.join(self.report_path, target_name)
QgsVectorFileWriter.writeAsVectorFormat(hazard_layer, self.hazard_path,
'CP1250', None,
'ESRI Shapefile')
file_info = QFileInfo(self.hazard_path)
hazard_layer = QgsVectorLayer(self.hazard_path, file_info.baseName(),
'ogr')
# hazard_layer.startEditing()
# field = QgsField('flooded', QVariant.Int)
# hazard_layer.dataProvider().addAttributes([field])
# hazard_layer.commitChanges()
# idx = hazard_layer.fieldNameIndex('flooded')
# expression = QgsExpression('count > 0')
# expression.prepare(hazard_layer.pendingFields())
#
# hazard_layer.startEditing()
# for feature in hazard_layer.getFeatures():
# feature[idx] = expression.evaluate(feature)
# hazard_layer.updateFeature(feature)
#
# hazard_layer.commitChanges()
# writing keywords
keyword_io = KeywordIO()
keywords = {
'field': 'state',
'hazard': 'generic',
'hazard_category': 'single_event',
'keyword_version': '3.5',
'layer_geometry': 'polygon',
'layer_mode': 'classified',
'layer_purpose': 'hazard',
'title': 'Flood',
'value_map': '{"high": [4], "medium": [3], '
'"low": [2], '
'"unaffected": ["None","","NULL",0,1]}',
'vector_hazard_classification': 'generic_vector_hazard_classes'
}
keyword_io.write_keywords(hazard_layer, keywords)
# copy layer styles
style_path = self.flood_fixtures_dir('flood_data_classified_state.qml')
target_style_path = os.path.join(self.report_path, 'flood_data.qml')
shutil.copy(style_path, target_style_path)
# archiving hazard layer
with ZipFile(self.hazard_zip_path, 'w') as zf:
for root, dirs, files in os.walk(self.report_path):
for f in files:
_, ext = os.path.splitext(f)
if 'flood_data' in f:
filename = os.path.join(root, f)
zf.write(filename, arcname=f)
def save_file(layer, output):
provider = layer.dataProvider()
writer = QgsVectorFileWriter.writeAsVectorFormat(layer, output, provider.encoding(), provider.crs())
return writer
def split_by_polygon_in_out(vector,
polygon_in,
polygon_out,
target_field,
value,
request=QgsFeatureRequest()):
"""Split a polygon layer updating the target field with the value.
All parts of vector layer will have their target_field updated to
value if they fall within polygon_in.
:param vector: A polygon vector layer to split.
:type vector: QgsVectorLayer
:param polygon_in: Polygon within which vector features will be considered
to be contained.
:type polygon_in: QgsGeometry
:param polygon_out: Polygon within which vector features will be considered
to be NOT contained.
:type polygon_out: QgsGeometry
:param target_field: Field in vector layer to be updated if features
are within polygon_in.
:type target_field: QgsField
:param value: Value to update the target field with if polygons are in.
:type value: int, float, str
:param request: Optional feature request used to subset the features
in vector.
:type request: QgsFeatureRequest
:return: QgsVectorLayer of split line for whichever is greater,
in our out polygons.
:rtype: QgsVectorLayer
"""
base_name = unique_filename()
file_name_in = base_name + '_in.shp'
file_name_out = base_name + '_out.shp'
file_name_poly_in = base_name + '_poly_in.shp'
file_name_poly_out = base_name + '_poly_out.shp'
# noinspection PyArgumentEqualDefault
line_layer_in = split_by_polygon2(vector,
polygon_in,
request,
use_contains_operation=False,
mark_value=(target_field, value))
line_layer_out = split_by_polygon2(vector,
polygon_out,
request,
use_contains_operation=True,
mark_value=(target_field, 0))
QgsVectorFileWriter.writeAsVectorFormat(line_layer_in, file_name_in,
"utf-8", None, "ESRI Shapefile")
QgsVectorFileWriter.writeAsVectorFormat(line_layer_out, file_name_out,
"utf-8", None, "ESRI Shapefile")
QgsVectorFileWriter.writeAsVectorFormat(polygon_in, file_name_poly_in,
"utf-8", None, "ESRI Shapefile")
QgsVectorFileWriter.writeAsVectorFormat(polygon_out, file_name_poly_out,
"utf-8", None, "ESRI Shapefile")
# merge layers
in_features = line_layer_in.featureCount()
out_features = line_layer_out.featureCount()
if in_features > out_features:
for feature in line_layer_out.getFeatures():
line_layer_in.dataProvider().addFeatures([feature])
return line_layer_in
else:
for feature in line_layer_in.getFeatures():
line_layer_out.dataProvider().addFeatures([feature])
return line_layer_out
def testWriteWithBinaryField(self):
"""
Test writing with a binary field
:return:
"""
basetestpath = tempfile.mkdtemp()
tmpfile = os.path.join(basetestpath, 'binaryfield.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test',
geom_type=ogr.wkbPoint,
options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('strfield', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('intfield', ogr.OFTInteger))
lyr.CreateField(ogr.FieldDefn('binfield', ogr.OFTBinary))
lyr.CreateField(ogr.FieldDefn('binfield2', ogr.OFTBinary))
f = None
ds = None
vl = QgsVectorLayer(tmpfile)
self.assertTrue(vl.isValid())
# check that 1 of its fields is a bool
fields = vl.fields()
self.assertEqual(
fields.at(fields.indexFromName('binfield')).type(),
QVariant.ByteArray)
dp = vl.dataProvider()
f = QgsFeature(fields)
bin_1 = b'xxx'
bin_2 = b'yyy'
bin_val1 = QByteArray(bin_1)
bin_val2 = QByteArray(bin_2)
f.setAttributes([1, 'str', 100, bin_val1, bin_val2])
self.assertTrue(dp.addFeature(f))
# write a gpkg package with a binary field
filename = os.path.join(str(QDir.tempPath()), 'with_bin_field')
rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat(
vl, filename, 'utf-8', vl.crs(), 'GPKG')
self.assertEqual(rc, QgsVectorFileWriter.NoError)
# open the resulting geopackage
vl = QgsVectorLayer(filename + '.gpkg', '', 'ogr')
self.assertTrue(vl.isValid())
fields = vl.fields()
# test type of converted field
idx = fields.indexFromName('binfield')
self.assertEqual(fields.at(idx).type(), QVariant.ByteArray)
idx2 = fields.indexFromName('binfield2')
self.assertEqual(fields.at(idx2).type(), QVariant.ByteArray)
# test values
self.assertEqual(vl.getFeature(1).attributes()[idx], bin_val1)
self.assertEqual(vl.getFeature(1).attributes()[idx2], bin_val2)
del vl
os.unlink(filename + '.gpkg')
def testDateTimeWriteShapefile(self):
"""Check writing date and time fields to an ESRI shapefile."""
ml = QgsVectorLayer(
('Point?crs=epsg:4326&field=id:int&'
'field=date_f:date&field=time_f:time&field=dt_f:datetime'),
'test', 'memory')
self.assertTrue(ml.isValid())
provider = ml.dataProvider()
self.assertIsNotNone(provider)
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(10, 10)))
ft.setAttributes([
1,
QDate(2014, 3, 5),
QTime(13, 45, 22),
QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))
])
res, features = provider.addFeatures([ft])
self.assertTrue(res)
self.assertTrue(features)
dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.shp')
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
# Open result and check
created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name),
'test', 'ogr')
fields = created_layer.dataProvider().fields()
self.assertEqual(
fields.at(fields.indexFromName('date_f')).type(), QVariant.Date)
# shapefiles do not support time types, result should be string
self.assertEqual(
fields.at(fields.indexFromName('time_f')).type(), QVariant.String)
# shapefiles do not support datetime types, result should be string
self.assertEqual(
fields.at(fields.indexFromName('dt_f')).type(), QVariant.String)
f = next(created_layer.getFeatures(QgsFeatureRequest()))
date_idx = created_layer.fields().lookupField('date_f')
self.assertIsInstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5))
time_idx = created_layer.fields().lookupField('time_f')
# shapefiles do not support time types
self.assertIsInstance(f.attributes()[time_idx], str)
self.assertEqual(f.attributes()[time_idx], '13:45:22')
# shapefiles do not support datetime types
datetime_idx = created_layer.fields().lookupField('dt_f')
self.assertIsInstance(f.attributes()[datetime_idx], str)
self.assertEqual(
f.attributes()[datetime_idx],
QDateTime(QDate(2014, 3, 5),
QTime(13, 45, 22)).toString("yyyy/MM/dd hh:mm:ss.zzz"))
def read_mf_head_dates(self):
QSWATMOD_path_dict = self.dirs_and_paths()
stdate, eddate, stdate_warmup, eddate_warmup = self.define_sim_period()
wd = QSWATMOD_path_dict['SMfolder']
startDate = stdate.strftime("%m-%d-%Y")
# Create swatmf_results tree inside
root = QgsProject.instance().layerTreeRoot()
if root.findGroup("swatmf_results"):
swatmf_results = root.findGroup("swatmf_results")
else:
swatmf_results = root.insertGroup(0, "swatmf_results")
input1 = QgsProject.instance().mapLayersByName("mf_grid (MODFLOW)")[0]
provider = input1.dataProvider()
'''
if self.dlg.checkBox_head.isChecked() and self.dlg.radioButton_mf_results_d.isChecked():
filename = "swatmf_out_MF_head"
# Open "swatmf_out_MF_head" file
y = ("MODFLOW", "--Calculated", "daily") # Remove unnecssary lines
with open(os.path.join(wd, filename), "r") as f:
data = [x.strip() for x in f if x.strip() and not x.strip().startswith(y)] # Remove blank lines
date = [x.strip().split() for x in data if x.strip().startswith("Day:")] # Collect only lines with dates
onlyDate = [x[1] for x in date] # Only date
# data1 = [x.split() for x in data] # make each line a list
sdate = datetime.datetime.strptime(startDate, "%m-%d-%Y") # Change startDate format
dateList = [(sdate + datetime.timedelta(days = int(i)-1)).strftime("%m-%d-%Y") for i in onlyDate]
self.dlg.comboBox_mf_results_sdate.clear()
self.dlg.comboBox_mf_results_sdate.addItems(dateList)
self.dlg.comboBox_mf_results_edate.clear()
self.dlg.comboBox_mf_results_edate.addItems(dateList)
self.dlg.comboBox_mf_results_edate.setCurrentIndex(len(dateList)-1)
# Copy mf_grid shapefile to swatmf_results tree
name = "mf_rch_daily"
name_ext = "mf_rch_daily.shp"
output_dir = QSWATMOD_path_dict['SMshps']
# Check if there is an exsting mf_head shapefile
if not any(lyr.name() == ("mf_rch_daily") for lyr in QgsProject.instance().mapLayers().values()):
mf_rch_shapfile = os.path.join(output_dir, name_ext)
QgsVectorFileWriter.writeAsVectorFormat(input1, mf_rch_shapfile,
"utf-8", input1.crs(), "ESRI Shapefile")
layer = QgsVectorLayer(mf_rch_shapfile, '{0}'.format("mf_rch_daily"), 'ogr')
# Put in the group
root = QgsProject.instance().layerTreeRoot()
swatmf_results = root.findGroup("swatmf_results")
QgsProject.instance().addMapLayer(layer, False)
swatmf_results.insertChildNode(0, QgsLayerTreeLayer(layer))
msgBox = QMessageBox()
msgBox.setWindowIcon(QtGui.QIcon(':/QSWATMOD2/pics/sm_icon.png'))
msgBox.setWindowTitle("Created!")
msgBox.setText("'mf_rch_daily.shp' file has been created in 'swatmf_results' group!")
msgBox.exec_()
'''
if self.dlg.checkBox_head.isChecked(
) and self.dlg.radioButton_mf_results_m.isChecked():
filename = "swatmf_out_MF_head_monthly"
# Open "swatmf_out_MF_head" file
y = ("Monthly") # Remove unnecssary lines
with open(os.path.join(wd, filename), "r") as f:
data = [
x.strip() for x in f
if x.strip() and not x.strip().startswith(y)
] # Remove blank lines
date = [
x.strip().split() for x in data if x.strip().startswith("month:")
] # Collect only lines with dates
onlyDate = [x[1] for x in date] # Only date
# data1 = [x.split() for x in data] # make each line a list
dateList = pd.date_range(startDate, periods=len(onlyDate),
freq='M').strftime("%b-%Y").tolist()
self.dlg.comboBox_mf_results_sdate.clear()
self.dlg.comboBox_mf_results_sdate.addItems(dateList)
self.dlg.comboBox_mf_results_edate.clear()
self.dlg.comboBox_mf_results_edate.addItems(dateList)
self.dlg.comboBox_mf_results_edate.setCurrentIndex(len(dateList) - 1)
# Copy mf_grid shapefile to swatmf_results tree
name = "mf_hd_monthly"
name_ext = "mf_hd_monthly.shp"
output_dir = QSWATMOD_path_dict['SMshps']
# Check if there is an exsting mf_head shapefile
if not any(
lyr.name() == ("mf_hd_monthly")
for lyr in list(QgsProject.instance().mapLayers().values())):
mf_hd_shapfile = os.path.join(output_dir, name_ext)
QgsVectorFileWriter.writeAsVectorFormat(input1, mf_hd_shapfile,
"utf-8", input1.crs(),
"ESRI Shapefile")
layer = QgsVectorLayer(mf_hd_shapfile,
'{0}'.format("mf_hd_monthly"), 'ogr')
# Put in the group
root = QgsProject.instance().layerTreeRoot()
swatmf_results = root.findGroup("swatmf_results")
QgsProject.instance().addMapLayer(layer, False)
swatmf_results.insertChildNode(0, QgsLayerTreeLayer(layer))
msgBox = QMessageBox()
msgBox.setWindowIcon(QtGui.QIcon(':/QSWATMOD2/pics/sm_icon.png'))
msgBox.setWindowTitle("Created!")
msgBox.setText(
"'mf_hd_monthly.shp' file has been created in 'swatmf_results' group!"
)
msgBox.exec_()
elif self.dlg.checkBox_head.isChecked(
) and self.dlg.radioButton_mf_results_y.isChecked():
filename = "swatmf_out_MF_head_yearly"
# Open "swatmf_out_MF_head" file
y = ("Yearly") # Remove unnecssary lines
with open(os.path.join(wd, filename), "r") as f:
data = [
x.strip() for x in f
if x.strip() and not x.strip().startswith(y)
] # Remove blank lines
date = [
x.strip().split() for x in data if x.strip().startswith("year:")
] # Collect only lines with dates
onlyDate = [x[1] for x in date] # Only date
# data1 = [x.split() for x in data] # make each line a list
dateList = pd.date_range(startDate, periods=len(onlyDate),
freq='A').strftime("%Y").tolist()
self.dlg.comboBox_mf_results_sdate.clear()
self.dlg.comboBox_mf_results_sdate.addItems(dateList)
self.dlg.comboBox_mf_results_edate.clear()
self.dlg.comboBox_mf_results_edate.addItems(dateList)
self.dlg.comboBox_mf_results_edate.setCurrentIndex(len(dateList) - 1)
# Copy mf_grid shapefile to swatmf_results tree
name = "mf_hd_yearly"
name_ext = "mf_hd_yearly.shp"
output_dir = QSWATMOD_path_dict['SMshps']
# Check if there is an exsting mf_head shapefile
if not any(
lyr.name() == ("mf_hd_yearly")
for lyr in list(QgsProject.instance().mapLayers().values())):
mf_hd_shapfile = os.path.join(output_dir, name_ext)
QgsVectorFileWriter.writeAsVectorFormat(input1, mf_hd_shapfile,
"utf-8", input1.crs(),
"ESRI Shapefile")
layer = QgsVectorLayer(mf_hd_shapfile,
'{0}'.format("mf_hd_yearly"), 'ogr')
# Put in the group
root = QgsProject.instance().layerTreeRoot()
swatmf_results = root.findGroup("swatmf_results")
QgsProject.instance().addMapLayer(layer, False)
swatmf_results.insertChildNode(0, QgsLayerTreeLayer(layer))
msgBox = QMessageBox()
msgBox.setWindowIcon(QtGui.QIcon(':/QSWATMOD2/pics/sm_icon.png'))
msgBox.setWindowTitle("Created!")
msgBox.setText(
"'mf_hd_yearly.shp' file has been created in 'swatmf_results' group!"
)
msgBox.exec_()
else:
self.dlg.comboBox_mf_results_sdate.clear()
def testWriteShapefileWithZ(self):
"""Check writing geometries with Z dimension to an ESRI shapefile."""
# start by saving a memory layer and forcing z
ml = QgsVectorLayer(('Point?crs=epsg:4326&field=id:int'), 'test',
'memory')
self.assertIsNotNone(ml, 'Provider not initialized')
self.assertTrue(ml.isValid(), 'Source layer not valid')
provider = ml.dataProvider()
self.assertIsNotNone(provider)
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromWkt('PointZ (1 2 3)'))
ft.setAttributes([1])
res, features = provider.addFeatures([ft])
self.assertTrue(res)
self.assertTrue(features)
# check with both a standard PointZ and 25d style Point25D type
for t in [QgsWkbTypes.PointZ, QgsWkbTypes.Point25D]:
dest_file_name = os.path.join(
str(QDir.tempPath()),
'point_{}.shp'.format(QgsWkbTypes.displayString(t)))
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile',
overrideGeometryType=t)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
# Open result and check
created_layer = QgsVectorLayer(
'{}|layerid=0'.format(dest_file_name), 'test', 'ogr')
f = next(created_layer.getFeatures(QgsFeatureRequest()))
g = f.geometry()
wkt = g.asWkt()
expWkt = 'PointZ (1 2 3)'
self.assertTrue(
compareWkt(expWkt, wkt),
"saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n"
% (expWkt, wkt))
# also try saving out the shapefile version again, as an extra test
# this tests that saving a layer with z WITHOUT explicitly telling the writer to keep z values,
# will stay retain the z values
dest_file_name = os.path.join(
str(QDir.tempPath()),
'point_{}_copy.shp'.format(QgsWkbTypes.displayString(t)))
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
created_layer, dest_file_name, 'utf-8', crs, 'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
# Open result and check
created_layer_from_shp = QgsVectorLayer(
'{}|layerid=0'.format(dest_file_name), 'test', 'ogr')
f = next(created_layer_from_shp.getFeatures(QgsFeatureRequest()))
g = f.geometry()
wkt = g.asWkt()
self.assertTrue(
compareWkt(expWkt, wkt),
"saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n"
% (expWkt, wkt))
def arbeite(self):
# QgsVectorFileWriter.writeAsVectorFormat(vlyr, newSQLiteFilePath, "utf-8", crs, "SQLite", False, None,
# ["SPATIALITE=YES"])
self.make_layers()
print("Connect DB and copy...")
dbabschn = QgsVectorLayer(self.dlg.fw_abschn.filePath(), "dbabschn",
"ogr")
db1030 = QgsVectorLayer(self.dlg.fw_1030.filePath(), "db1030", "ogr")
db255 = QgsVectorLayer(self.dlg.fw_255.filePath(), "db255", "ogr")
QgsVectorFileWriter.writeAsVectorFormat(
dbabschn,
self.dlg.fw_speichern.filePath() + "\dbabschn.sqlite", "utf-8",
QgsCoordinateReferenceSystem(), "SQLite")
QgsVectorFileWriter.writeAsVectorFormat(
db255,
self.dlg.fw_speichern.filePath() + "\db000255.sqlite", "utf-8",
QgsCoordinateReferenceSystem(), "SQLite")
QgsVectorFileWriter.writeAsVectorFormat(
db1030,
self.dlg.fw_speichern.filePath() + "\db001030.sqlite", "utf-8",
QgsCoordinateReferenceSystem(), "SQLite")
mem_db = sqlite3.connect(':memory:') # create a memory database
for old_db_pfad in [
self.dlg.fw_speichern.filePath() + "\dbabschn.sqlite",
self.dlg.fw_speichern.filePath() + "\db000255.sqlite",
self.dlg.fw_speichern.filePath() + "\db001030.sqlite"
]:
old_db = sqlite3.connect(old_db_pfad)
c = old_db.cursor()
c.execute('''DROP TABLE geometry_columns''')
c.execute('''DROP TABLE spatial_ref_sys''')
query = "".join(line for line in old_db.iterdump())
mem_db.executescript(query)
daten = mem_db.cursor()
mem_db.create_function("sqrt", 1, QDViewer.sqrt)
print("Tabellen anlegen...")
daten.execute(
'''CREATE TABLE "tmp11" ("VNK" varchar(10), "NNK" varchar(10), "SORT" float, "XKOORD" float,
"YKOORD" float, "STAND" text, "FLAG" varchar(1), DX float default 0, DY float default 0,
laenge float default NULL, STATION float default NULL, ABSTAND float default NULL)'''
)
daten.execute(
'''CREATE TABLE "tmp12" ("VNK" varchar(10), "NNK" varchar(10), "SORT" float, "XKOORD" float,
"YKOORD" float, "STAND" text, "FLAG" varchar(1), DX float default 0, DY float default 0,
laenge float default NULL, STATION float default NULL, ABSTAND float default NULL)'''
)
daten.execute(
'''CREATE TABLE "tmp13" ("VNK" varchar(10), "NNK" varchar(10), "SORT" float, "XKOORD" float,
"YKOORD" float, "STAND" text, "FLAG" varchar(1), DX float default 0, DY float default 0,
laenge float default NULL, STATION float default NULL, ABSTAND float default NULL)'''
)
daten.execute(
'''CREATE TABLE "tmp14" ("VNK" varchar(10), "NNK" varchar(10), "SORT" float, "XKOORD" float,
"YKOORD" float, "STAND" text, "FLAG" varchar(1), DX float default 0, DY float default 0,
laenge float default NULL, STATION float default NULL, ABSTAND float default NULL,
DXP float default 0, DYP float default 0)''')
# DX/DY berechnen
print("DX/DY berechnen...")
daten.execute('''INSERT INTO tmp11
SELECT a.VNK, a.NNK, a.SORT, a.XKOORD, a.YKOORD, a.STAND, a.FLAG, (b.XKOORD - a.XKOORD) DX,
(b.YKOORD - a.YKOORD) DY, NULL, NULL, NULL FROM DB000255 a, DB000255 b
WHERE a.VNK = b.VNK AND a.NNK = b.NNK AND a.SORT = (b.SORT + 1);'''
)
# Laenge berechnen und Vektor DX/DY zu Einheitsvektor
print("Laenge berechnen und Vektor DX/DY zu Einheitsvektor...")
daten.execute(
'''UPDATE tmp11 SET laenge = sqrt(DX*DX+DY*DY), DX = DX / sqrt(DX*DX+DY*DY),
DY = DY / sqrt(DX*DX+DY*DY) WHERE DX != 0 OR DY != 0;''')
# DX/DY vom zweiten Punkt für ersten übernehmen
print("DX/DY vom zweiten Punkt für ersten übernehmen...")
daten.execute('''INSERT INTO tmp11
SELECT a.VNK, a.NNK, a.SORT, a.XKOORD, a.YKOORD, a.STAND, a.FLAG, b.DX DX, b.DY DY, 0, 0, 0
FROM DB000255 a, tmp11 b
WHERE a.VNK = b.VNK AND a.NNK = b.NNK AND a.SORT = 1 AND b.SORT = 2;'''
)
# ABSTAND berechnen (Summe der Laenge)
print("ABSTAND berechnen (Summe der Laenge)...")
daten.execute('''INSERT INTO tmp12
SELECT a.VNK, a.NNK, a.SORT, a.XKOORD, a.YKOORD, a.STAND, a.FLAG, a.DX, a.DY, a.laenge, NULL, SUM(b.laenge)
FROM tmp11 a, tmp11 b
WHERE a.VNK = b.VNK AND a.NNK = b.NNK AND a.SORT >= b.SORT GROUP BY a.VNK, a.NNK, a.SORT;'''
)
# Station berechnen
print("Station berechnen...")
daten.execute('''INSERT INTO tmp13
SELECT a.VNK, a.NNK, a.SORT, a.XKOORD, a.YKOORD, a.STAND, a.FLAG, a.DX, a.DY, a.laenge,
a.ABSTAND * b.faktor , a.ABSTAND
FROM tmp12 a,
(SELECT b.VNK, b.NNK, c.LEN / max(b.ABSTAND) faktor FROM tmp12 b, DBABSCHN c
WHERE b.VNK = c.VNK AND b.NNK = c.NNK GROUP BY b.VNK, b.NNK) b
WHERE a.VNK = b.VNK AND a.NNK = b.NNK
GROUP BY a.VNK, a.NNK, a.SORT;''')
# DXP/DYP berechnen (Verschiebe-Vektor an Stützpunkten)
print("DXP/DYP berechnen (Verschiebe-Vektor an Stützpunkten)...")
daten.execute('''INSERT INTO tmp14
SELECT a.*, a.DX + b.DX, a.DY + b.DY
FROM tmp13 a, tmp13 b
WHERE a.VNK = b.VNK AND a.NNK = b.NNK AND a.SORT = (b.SORT - 1);'''
)
# Letzten Punkt übernehmen
print("Letzten Punkt übernehmen...")
daten.execute('''INSERT INTO tmp14
SELECT a.*, a.DX, a.DY
FROM tmp13 a, (SELECT VNK, NNK, max(SORT) SORT FROM tmp13 GROUP BY VNK, NNK) b
WHERE a.VNK = b.VNK AND a.NNK = b.NNK AND a.SORT = b.SORT;''')
# DXP/DYP zu Einheitsvektor
print("DXP/DYP zu Einheitsvektor...")
daten.execute(
'''UPDATE tmp14 SET DXP = DXP / sqrt(DXP*DXP+DYP*DYP), DYP = DYP / sqrt(DXP*DXP+DYP*DYP)
WHERE DXP != 0 OR DYP != 0;''')
mem_db.commit()
print("Querschnitte summieren:")
print("Tabellen anlegen...")
daten.execute(
'''CREATE TABLE tmp1 ("VNK" varchar(10), "NNK" varchar(10), "VST" float,
"BST" float, "STREIFEN" varchar(1), "STREIFENNR" float, "ART" varchar(3),
"ARTOBER" varchar(3), "BREITE" float, "BISBREITE" float, "BLPART" varchar(2),
"BLPART3" varchar(5), "UIPART" varchar(2), "UIPART3" varchar(5), "LAENGE" float,
"FLAECHE" float, "BAUJAHRGEW" text, "ABNAHMEGEW" text, "DAUERGEW" float, "ABLAUFGEW" text,
"ERFART" varchar(2), "QUELLE" varchar(2), "ADATUM" text, "BEMERKUNG" varchar(254),
"BEARBEITER" varchar(64), "STAND" text, "PARENTID" varchar(32), "OBJEKTID" varchar(32),
"FLAG" varchar(1), ABSTAND_VST1 float default 0, ABSTAND_VST2 float default 0, ABSTAND_BST1 float default 0,
ABSTAND_BST2 float default 0);''')
daten.execute(
'''CREATE TABLE tmp2 ("VNK" varchar(10), "NNK" varchar(10), "VST" float,
"BST" float, "STREIFEN" varchar(1), "STREIFENNR" float, "ART" varchar(3),
"ARTOBER" varchar(3), "BREITE" float, "BISBREITE" float, "BLPART" varchar(2),
"BLPART3" varchar(5), "UIPART" varchar(2), "UIPART3" varchar(5), "LAENGE" float,
"FLAECHE" float, "BAUJAHRGEW" text, "ABNAHMEGEW" text, "DAUERGEW" float, "ABLAUFGEW" text,
"ERFART" varchar(2), "QUELLE" varchar(2), "ADATUM" text, "BEMERKUNG" varchar(254),
"BEARBEITER" varchar(64), "STAND" text, "PARENTID" varchar(32), "OBJEKTID" varchar(32),
"FLAG" varchar(1), ABSTAND_VST1 float default 0, ABSTAND_VST2 float default 0, ABSTAND_BST1 float default 0,
ABSTAND_BST2 float default 0);''')
print("Summe links und rechts...")
daten.execute(
'''INSERT INTO tmp1 SELECT a.VNK, a.NNK, a.VST, a.BST, a.STREIFEN, a.STREIFENNR, a.ART, a.ARTOBER,
a.BREITE, a.BISBREITE, a.BLPART, a.BLPART3, a.UIPART, a.UIPART3, a.LAENGE, a.FLAECHE, a.BAUJAHRGEW,
a.ABNAHMEGEW, a.DAUERGEW, a.ABLAUFGEW, a.ERFART, a.QUELLE, a.ADATUM, a.BEMERKUNG, a.BEARBEITER, a.STAND,
a.PARENTID, a.OBJEKTID, a.FLAG,
(SUM(b.BREITE)) ABSTAND_VST1,
NULL,
(SUM(b.BISBREITE)) ABSTAND_BST1,
NULL
FROM DB001030 a, DB001030 b WHERE a.VNK = b.VNK
AND b.NNK = a.NNK AND a.VST = b.VST AND a.STREIFEN = b.STREIFEN AND a.STREIFENNR > b.STREIFENNR
and a.STREIFEN != "M"
GROUP BY a.VNK, a.NNK, a.VST, a.STREIFEN, a.STREIFENNR;''')
print("Streifen 1 kopieren...")
daten.execute('''INSERT INTO tmp1
SELECT VNK, NNK, VST,BST, STREIFEN, STREIFENNR, ART, ARTOBER, BREITE, BISBREITE, BLPART, BLPART3, UIPART,
UIPART3, LAENGE, FLAECHE, BAUJAHRGEW, ABNAHMEGEW, DAUERGEW, ABLAUFGEW, ERFART, QUELLE, ADATUM, BEMERKUNG,
BEARBEITER, STAND, PARENTID, OBJEKTID, FLAG, 0 ABSTAND_VST1, NULL ABSTAND_VST2, 0 ABSTAND_BST1,
NULL ABSTAND_BST2 FROM DB001030 WHERE STREIFENNR = 1;''')
print("Mittelstreifen addieren...")
daten.execute('''INSERT INTO tmp2
SELECT a.VNK, a.NNK, a.VST,a.BST,a.STREIFEN,a.STREIFENNR,a.ART,a.ARTOBER,a.BREITE,a.BISBREITE,a.BLPART,
a.BLPART3, a.UIPART,a.UIPART3,a.LAENGE,a.FLAECHE,a.BAUJAHRGEW,a.ABNAHMEGEW,a.DAUERGEW,a.ABLAUFGEW,a.ERFART,
a.QUELLE, a.ADATUM, a.BEMERKUNG,a.BEARBEITER,a.STAND,a.PARENTID,a.OBJEKTID,a.FLAG,
(a.ABSTAND_VST1+round(IFNULL(m.BREITE,0) / 2)) ABSTAND_VST1,
NULL ABSTAND_VST2,
(a.ABSTAND_BST1+round(IFNULL(m.BISBREITE,0) / 2)) ABSTAND_BST1,
NULL ABSTAND_BST2
FROM tmp1 a left join (select * from DB001030 where STREIFEN = "M") m
on a.VNK = m.VNK AND a.NNK = m.NNK AND a.VST = m.VST;''')
print("Abstand der Außenkante berechnen...")
daten.execute('''UPDATE tmp2
SET ABSTAND_VST2 = ABSTAND_VST1 + BREITE,
ABSTAND_BST2 = ABSTAND_BST1 + BISBREITE;''')
print("Linke drehen...")
daten.execute('''UPDATE tmp2 SET
ABSTAND_VST1 = - ABSTAND_VST1,
ABSTAND_VST2 = - ABSTAND_VST2,
ABSTAND_BST1 = - ABSTAND_BST1,
ABSTAND_BST2 = - ABSTAND_BST2 WHERE STREIFEN = "L";''')
print("Mittelstreifen berechnen...")
daten.execute('''INSERT INTO tmp2
SELECT VNK, NNK, VST, BST, STREIFEN, STREIFENNR, ART, ARTOBER, BREITE, BISBREITE, BLPART, BLPART3, UIPART,
UIPART3, LAENGE, FLAECHE, BAUJAHRGEW, ABNAHMEGEW, DAUERGEW, ABLAUFGEW, ERFART, QUELLE, ADATUM, BEMERKUNG,
BEARBEITER, STAND, PARENTID, OBJEKTID, FLAG,
ROUND(- BREITE / 2) ABSTAND_VST1,
ROUND(BREITE / 2) ABSTAND_VST2,
ROUND(- BISBREITE / 2) ABSTAND_BST1,
ROUND(BISBREITE / 2) ABSTAND_BST2 FROM DB001030 WHERE STREIFEN = "M";'''
)
print("Nicht benötigte Tabellen löschen...")
daten.execute('''DROP TABLE tmp11''')
daten.execute('''DROP TABLE tmp12''')
daten.execute('''DROP TABLE tmp13''')
daten.execute('''DROP TABLE tmp1''')
mem_db.commit()
print("Arbeiten...")
# Abschnitte selektieren und durchgehen
daten.execute('SELECT VNK, NNK, LEN FROM DBABSCHN')
abschn = daten.fetchall()
for row in abschn:
# Koordinaten der Achse abfragen
sql = 'SELECT STATION, XKOORD, YKOORD, DXP, DYP, DX, DY FROM tmp14 WHERE VNK = "' + row[0] + '" AND ' \
'NNK = "' + row[1] + '" AND STATION IS NOT NULL AND XKOORD IS NOT NULL AND YKOORD IS NOT NULL AND ' \
'DX IS NOT NULL AND DY IS NOT NULL ORDER BY SORT'
daten.execute(sql)
punkte = daten.fetchall()
# Achse als WKT ablegen
self.write_linestring(punkte, row)
# Querschnitte laden
sql = 'SELECT VST, BST, STREIFEN, STREIFENNR, ABSTAND_VST1, ABSTAND_VST2, ABSTAND_BST1, ABSTAND_BST2,' + \
' ART,ARTOBER, BREITE, BISBREITE, BLPART, BLPART3, UIPART, UIPART3, LAENGE, FLAECHE, BAUJAHRGEW,' + \
'ABNAHMEGEW, DAUERGEW, ABLAUFGEW, ERFART, QUELLE, ADATUM, BEMERKUNG, BEARBEITER, STAND, PARENTID, ' \
'OBJEKTID, FLAG FROM tmp2 WHERE VNK = "' + row[0] + '" AND NNK = "' + row[1] + '" AND ' + \
'ABSTAND_VST1 IS NOT NULL AND ABSTAND_VST2 IS NOT NULL AND ABSTAND_BST1 IS NOT NULL AND ' \
'ABSTAND_BST2 IS NOT NULL ORDER BY VST, STREIFEN, STREIFENNR'
daten.execute(sql)
for quer in daten.fetchall():
# print(quer)
x = []
y = []
c = 0
pa = None
for p in punkte:
if p[0] >= quer[0] and c == 0 and pa is not None:
# Berechnung Anfangspunkt
dx = p[1] - pa[1]
dy = p[2] - pa[2]
diff = p[0] - pa[0]
f = 0
if diff > 0:
f = (quer[0] - pa[0]) / diff
# print(f)
dxn, dyn, s = QDViewer.norm(dx, dy)
# print("P1")
# print(quer[4])
if quer[4] is not None:
x.append(pa[1] + dx * f + dyn * quer[4] / 100)
y.append(pa[2] + dy * f - dxn * quer[4] / 100)
x.append(pa[1] + dx * f + dyn * quer[5] / 100)
y.append(pa[2] + dy * f - dxn * quer[5] / 100)
c = 1
if c == 1 and p[0] <= quer[1]:
# print("P2")
# Prozentualer Abstand
f = (p[0] - quer[0]) / (quer[1] - quer[0])
# print(f)
# Abstand interpolieren
a = quer[4] + f * (quer[6] - quer[4])
# print(a)
# Abstand2 interpolieren
b = quer[5] + f * (quer[7] - quer[5])
# print(b)
try:
x.insert(0, p[1] - p[4] * a / 100)
y.insert(0, p[2] + p[3] * a / 100)
x.append(p[1] - p[4] * b / 100)
y.append(p[2] + p[3] * b / 100)
except TypeError:
break
if c == 1 and p[0] > quer[1]:
# print("P3")
# Berechnung Endpunkt
dx = p[1] - pa[1]
dy = p[2] - pa[2]
if (p[0] - pa[0]) != 0:
f = (quer[1] - pa[0]) / (p[0] - pa[0])
else:
f = 1
# print(p[0])
# print(f)
dxn, dyn, s = QDViewer.norm(dx, dy)
if quer[6] is not None:
x.insert(0, pa[1] + dx * f + dyn * quer[6] / 100)
y.insert(0, pa[2] + dy * f - dxn * quer[6] / 100)
if quer[7] is not None:
x.append(pa[1] + dx * f + dyn * quer[7] / 100)
y.append(pa[2] + dy * f - dxn * quer[7] / 100)
break
pa = p
self.write_polygon(x, y, row, quer)
print("Fertig")
def testWriteShapefileWithAttributeSubsets(self):
"""Tests writing subsets of attributes to files."""
ml = QgsVectorLayer((
'Point?crs=epsg:4326&field=id:int&field=field1:int&field=field2:int&field=field3:int'
), 'test', 'memory')
self.assertIsNotNone(ml, 'Provider not initialized')
self.assertTrue(ml.isValid(), 'Source layer not valid')
provider = ml.dataProvider()
self.assertIsNotNone(provider)
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromWkt('Point (1 2)'))
ft.setAttributes([1, 11, 12, 13])
res, features = provider.addFeatures([ft])
self.assertTrue(res)
self.assertTrue(features)
# first write out with all attributes
dest_file_name = os.path.join(str(QDir.tempPath()),
'all_attributes.shp')
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile', attributes=[])
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
# Open result and check
created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name),
'test', 'ogr')
self.assertEqual(created_layer.fields().count(), 4)
f = next(created_layer.getFeatures(QgsFeatureRequest()))
self.assertEqual(f['id'], 1)
self.assertEqual(f['field1'], 11)
self.assertEqual(f['field2'], 12)
self.assertEqual(f['field3'], 13)
# now test writing out only a subset of attributes
dest_file_name = os.path.join(str(QDir.tempPath()),
'subset_attributes.shp')
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile',
attributes=[1, 3])
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
# Open result and check
created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name),
'test', 'ogr')
self.assertEqual(created_layer.fields().count(), 2)
f = next(created_layer.getFeatures(QgsFeatureRequest()))
self.assertEqual(f['field1'], 11)
self.assertEqual(f['field3'], 13)
# finally test writing no attributes
dest_file_name = os.path.join(str(QDir.tempPath()),
'no_attributes.shp')
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile',
skipAttributeCreation=True)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
# Open result and check
created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name),
'test', 'ogr')
# expect only a default 'FID' field for shapefiles
self.assertEqual(created_layer.fields().count(), 1)
self.assertEqual(created_layer.fields()[0].name(), 'FID')
# in this case we also check that the geometry exists, to make sure feature has been correctly written
# even without attributes
f = next(created_layer.getFeatures(QgsFeatureRequest()))
g = f.geometry()
wkt = g.asWkt()
expWkt = 'Point (1 2)'
self.assertTrue(
compareWkt(expWkt, wkt),
"geometry not saved correctly when saving without attributes : mismatch Expected:\n%s\nGot:\n%s\n"
% (expWkt, wkt))
self.assertEqual(f['FID'], 0)
def export_polys(self):
"""
Export ESUs
:return:
"""
canvas = self.iface.mapCanvas()
clayer = canvas.currentLayer()
# will return 0 if none selected
count = clayer.selectedFeatureCount()
feature_count = clayer.featureCount()
# Get list of selected features
selected_poly_ids = list()
if count > 0:
selectedfeats = clayer.selectedFeatures()
for feat in selectedfeats:
selected_poly_ids.append(int(feat.attribute('rd_pol_id')))
feature_count = clayer.selectedFeatureCount()
self.warn_about_selected_features(feature_count)
# Prepare sql query
if self.unassigned:
polyexportsql = self.sql_queries['export_all']
else:
polyexportsql = self.sql_queries['export_assigned_only']
# SQL to filter out unselected and/or public road records
if count > 0:
polyexportsql += " WHERE rd_pol_id IN ({})".format(', '.join(
map(str, selected_poly_ids)))
else:
polyexportsql += " WHERE rd_pol_id IS NOT NULL"
if self.public_only:
polyexportsql += " AND is_public = 1"
# Setup database temporary tables
for table in ['maint_records']:
# Drop tables if left behind from last export
args = {'table': table}
query = self.run_sql('drop_table', args)
query = self.run_sql('create_maint_records')
# Run the main query
if config.DEBUG_MODE:
print(polyexportsql)
query = QSqlQuery(self.db)
query.setForwardOnly(True)
query.exec_(polyexportsql)
if query.isActive() is False:
raise StandardError('Database query problem: {}'.format(
query.lastError().text()))
# create layer
vlayer = QgsVectorLayer("multipolygon?crs=EPSG:27700", "temp",
"memory")
vlayer.setCrs(
QgsCoordinateReferenceSystem(
27700, QgsCoordinateReferenceSystem.EpsgCrsId))
provider = vlayer.dataProvider()
# add fields
self.fields = [
QgsField("poly_id", QVariant.String),
QgsField("RefNo", QVariant.LongLong),
QgsField("rec_type", QVariant.Int),
QgsField("desctxt", QVariant.String),
QgsField("Locality", QVariant.String),
QgsField("Town", QVariant.String),
QgsField("LocTxt", QVariant.String),
QgsField("RdStatus", QVariant.LongLong),
QgsField("Swa_org", QVariant.String),
QgsField("Adopt_Date", QVariant.Date),
QgsField("Entry_Date", QVariant.Date),
QgsField("lor_no", QVariant.Int),
QgsField("route", QVariant.String),
QgsField("symbol", QVariant.Int),
QgsField("element", QVariant.String),
QgsField("hierarchy", QVariant.String)
]
provider.addAttributes(self.fields)
vlayer.updateFields()
# Exit if output file path is invalid
if len(str(self.export_path)) < 0:
return False
if self.check_if_export_file_in_use():
return False
# Run through SQL results creating features from records
self.progresswin.show()
i = 0
while query.next():
if self.progresswin.wasCanceled():
self.kill_export()
break
record = query.record()
new_feature = self.create_feature_from_record(record)
provider.addFeatures([new_feature])
# Update progress bar
i += 1
diff = feature_count + (
i - feature_count) if i > feature_count else feature_count
self.percent_complete = (i / float(diff)) * 100
self.progresswin.setValue(self.percent_complete)
if self.killed:
# Show message and exit if killed
export_error_msg_box = QMessageBox(
QMessageBox.Warning, " ",
"An error occurred while exporting the"
"shapefile", QMessageBox.Ok, None)
export_error_msg_box.setWindowFlags(Qt.CustomizeWindowHint
| Qt.WindowTitleHint)
export_error_msg_box.exec_()
return False
vlayer.updateExtents()
result = QgsVectorFileWriter.writeAsVectorFormat(
vlayer, self.export_path, "utf-8", None, "ESRI Shapefile")
# checks for completed export
if result == 0:
self.progresswin.close()
if config.DEBUG_MODE:
print('DEBUG_MODE: {} features exported'.format(
vlayer.featureCount()))
return True
def testOverwriteLayer(self):
"""Tests writing a layer with a field value converter."""
ml = QgsVectorLayer('Point?field=firstfield:int', 'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([1])
provider.addFeatures([ft])
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename, update=1)
lyr = ds.GetLayerByName('test')
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 1)
ds.CreateLayer('another_layer')
del f
del lyr
del ds
caps = QgsVectorFileWriter.editionCapabilities(filename)
self.assertTrue((caps & QgsVectorFileWriter.CanAddNewLayer))
self.assertTrue((caps & QgsVectorFileWriter.CanAppendToExistingLayer))
self.assertTrue(
(caps & QgsVectorFileWriter.CanAddNewFieldsToExistingLayer))
self.assertTrue((caps & QgsVectorFileWriter.CanDeleteLayer))
self.assertTrue(QgsVectorFileWriter.targetLayerExists(
filename, 'test'))
self.assertFalse(
QgsVectorFileWriter.areThereNewFieldsToCreate(
filename, 'test', ml, [0]))
# Test CreateOrOverwriteLayer
ml = QgsVectorLayer('Point?field=firstfield:int', 'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([2])
provider.addFeatures([ft])
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename)
lyr = ds.GetLayerByName('test')
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 2)
# another_layer should still exist
self.assertIsNotNone(ds.GetLayerByName('another_layer'))
del f
del lyr
del ds
# Test CreateOrOverwriteFile
ml = QgsVectorLayer('Point?field=firstfield:int', 'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([3])
provider.addFeatures([ft])
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename)
lyr = ds.GetLayerByName('test')
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 3)
# another_layer should no longer exist
self.assertIsNone(ds.GetLayerByName('another_layer'))
del f
del lyr
del ds
# Test AppendToLayerNoNewFields
ml = QgsVectorLayer('Point?field=firstfield:int&field=secondfield:int',
'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([4, -10])
provider.addFeatures([ft])
self.assertTrue(
QgsVectorFileWriter.areThereNewFieldsToCreate(
filename, 'test', ml, [0, 1]))
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
options.actionOnExistingFile = QgsVectorFileWriter.AppendToLayerNoNewFields
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename)
lyr = ds.GetLayerByName('test')
self.assertEqual(lyr.GetLayerDefn().GetFieldCount(), 1)
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 3)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 4)
del f
del lyr
del ds
# Test AppendToLayerAddFields
ml = QgsVectorLayer('Point?field=firstfield:int&field=secondfield:int',
'test', 'memory')
provider = ml.dataProvider()
ft = QgsFeature()
ft.setAttributes([5, -1])
provider.addFeatures([ft])
self.assertTrue(
QgsVectorFileWriter.areThereNewFieldsToCreate(
filename, 'test', ml, [0, 1]))
options = QgsVectorFileWriter.SaveVectorOptions()
options.driverName = 'GPKG'
options.layerName = 'test'
options.actionOnExistingFile = QgsVectorFileWriter.AppendToLayerAddFields
filename = '/vsimem/out.gpkg'
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, filename, options)
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
ds = ogr.Open(filename)
lyr = ds.GetLayerByName('test')
self.assertEqual(lyr.GetLayerDefn().GetFieldCount(), 2)
self.assertIsNotNone(lyr)
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 3)
if hasattr(f, "IsFieldSetAndNotNull"):
# GDAL >= 2.2
self.assertFalse(f.IsFieldSetAndNotNull('secondfield'))
else:
self.assertFalse(f.IsFieldSet('secondfield'))
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 4)
if hasattr(f, "IsFieldSetAndNotNull"):
self.assertFalse(f.IsFieldSetAndNotNull('secondfield'))
else:
self.assertFalse(f.IsFieldSet('secondfield'))
f = lyr.GetNextFeature()
self.assertEqual(f['firstfield'], 5)
self.assertEqual(f['secondfield'], -1)
del f
del lyr
del ds
gdal.Unlink(filename)
def processPointsLayer(self, feedback, layer, mapAttr, resultProj):
feedback.setProgressText("Publishing map: " +
UTILS.normalizeName(layer.name()))
clonedLayer = layer.clone()
layerRenderer = clonedLayer.renderer()
renderContext = QgsRenderContext()
renderContext.setUseAdvancedEffects(True)
renderContext.setFlags(QgsRenderContext.Flag.Antialiasing)
imageList = list()
iconField = QgsField(
'icon_url', QVariant.String,
'text') #Danilo não vou verificar se o mapa ja tem esse atributo
feedback.setProgressText("Adding a column 'icon_url'")
clonedLayer.startEditing()
addedField = clonedLayer.addAttribute(iconField)
if (addedField == False):
feedback.pushConsoleInfo(
"Warning: " + layer.name() +
" canceled failed to create a column to store the point symbol."
)
return False
clonedLayer.commitChanges()
clonedLayer.startEditing()
feedback.setProgressText("Rendering symbologies")
for feature in clonedLayer.getFeatures():
layerRenderer.startRender(renderContext, clonedLayer.fields())
symbol = layerRenderer.originalSymbolsForFeature(
feature, renderContext)
if len(symbol) <= 0:
continue
else:
if len(symbol) > 1:
feedback.pushConsoleInfo(
"Warning: Only one symbol for symbology, the others will be ignored."
)
symbol = symbol[0]
layerRenderer.stopRender(renderContext)
curImage = symbol.asImage(QSize(24, 24))
try:
imgIndex = imageList.index(curImage)
except Exception as e:
imageList.append(curImage)
imgIndex = len(imageList) - 1
feature.setAttribute("icon_url", './' + str(imgIndex) + ".png")
clonedLayer.updateFeature(feature)
clonedLayer.commitChanges()
layerCsvFolder = self.getPathForMap(layer.name(), mapAttr, 'csv')
feedback.setProgressText("Saving results")
os.makedirs(layerCsvFolder, exist_ok=True)
savedCsv = QgsVectorFileWriter.writeAsVectorFormat(
clonedLayer,
os.path.join(layerCsvFolder, 'point_layer.csv'),
'utf-8',
resultProj,
'CSV',
layerOptions=['GEOMETRY=AS_XY'])
#Saving symbology
for index in range(len(imageList)):
imageList[index].save(
os.path.join(layerCsvFolder,
str(index) + '.png'))
return savedCsv and len(imageList) > 0
def test_representValue(self):
def _test(layer, is_gpkg=False):
# Skip fid and precision tests
offset = 1 if is_gpkg else 0
fieldFormatter = QgsFallbackFieldFormatter()
QLocale.setDefault(QLocale('en'))
# Precision is ignored for integers and longlongs
self.assertEqual(
fieldFormatter.representValue(layer, 0 + offset, {}, None,
'123'), '123')
self.assertEqual(
fieldFormatter.representValue(layer, 0 + offset, {}, None,
'123000'), '123,000')
self.assertEqual(
fieldFormatter.representValue(layer, 0 + offset, {}, None,
'9999999'), '9,999,999')
self.assertEqual(
fieldFormatter.representValue(layer, 0 + offset, {}, None,
None), 'NULL')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
'123'), '123')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
'123000'), '123,000')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
'9999999'), '9,999,999')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
None), 'NULL')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
None), 'NULL')
if not is_gpkg:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123'), '123.00000')
else:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123'), '123')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
None), 'NULL')
if not is_gpkg:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123000'), '123,000.00000')
else:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123000'), '123,000')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'0'), '0')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'0.127'), '0.127')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'1.27e-1'), '0.127')
if not is_gpkg:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'-123'), '-123.00000')
else:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'-123'), '-123')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'-0.127'), '-0.127')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'-1.27e-1'), '-0.127')
# Check with Italian locale
QLocale.setDefault(QLocale('it'))
self.assertEqual(
fieldFormatter.representValue(layer, 0 + offset, {}, None,
'9999999'),
'9.999.999') # scientific notation for integers!
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
'123'), '123')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
'123000'), '123.000')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
'9999999'), '9.999.999')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
None), 'NULL')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
None), 'NULL')
if not is_gpkg:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123000'), '123.000,00000')
else:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123000'), '123.000')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'0'), '0')
if not is_gpkg:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123'), '123,00000')
else:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123'), '123')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'0.127'), '0,127')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'1.27e-1'), '0,127')
if not is_gpkg:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'-123'), '-123,00000')
else:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'-123'), '-123')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'-0.127'), '-0,127')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'-1.27e-1'), '-0,127')
# Check with custom locale without thousand separator
custom = QLocale('en')
custom.setNumberOptions(QLocale.OmitGroupSeparator)
QLocale.setDefault(custom)
self.assertEqual(
fieldFormatter.representValue(layer, 0 + offset, {}, None,
'9999999'),
'9999999') # scientific notation for integers!
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
'123'), '123')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
'9999999'), '9999999')
if not is_gpkg:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123000'), '123000.00000')
else:
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
'123000'), '123000')
# Check string
self.assertEqual(
fieldFormatter.representValue(layer, 3 + offset, {}, None,
'123'), '123')
self.assertEqual(
fieldFormatter.representValue(layer, 3 + offset, {}, None,
'a string'), 'a string')
self.assertEqual(
fieldFormatter.representValue(layer, 3 + offset, {}, None, ''),
'')
self.assertEqual(
fieldFormatter.representValue(layer, 3 + offset, {}, None,
None), 'NULL')
# Check NULLs (this is what happens in real life inside QGIS)
self.assertEqual(
fieldFormatter.representValue(layer, 0 + offset, {}, None,
QVariant(QVariant.String)),
'NULL')
self.assertEqual(
fieldFormatter.representValue(layer, 1 + offset, {}, None,
QVariant(QVariant.String)),
'NULL')
self.assertEqual(
fieldFormatter.representValue(layer, 2 + offset, {}, None,
QVariant(QVariant.String)),
'NULL')
self.assertEqual(
fieldFormatter.representValue(layer, 3 + offset, {}, None,
QVariant(QVariant.String)),
'NULL')
memory_layer = QgsVectorLayer(
"point?field=int:integer&field=double:double&field=long:long&field=string:string",
"layer", "memory")
self.assertTrue(memory_layer.isValid())
_test(memory_layer)
# Test a shapefile
shape_path = writeShape(memory_layer, 'test_qgsfieldformatters.shp')
shapefile_layer = QgsVectorLayer(shape_path, 'test', 'ogr')
self.assertTrue(shapefile_layer.isValid())
_test(shapefile_layer)
gpkg_path = tempfile.mktemp('.gpkg')
# Test a geopackage
_, _ = QgsVectorFileWriter.writeAsVectorFormat(memory_layer, gpkg_path,
'utf-8',
memory_layer.crs(),
'GPKG', False, [], [],
False)
gpkg_layer = QgsVectorLayer(gpkg_path, 'test', 'ogr')
self.assertTrue(gpkg_layer.isValid())
# No precision here
_test(gpkg_layer, True)
def route(self):
try:
import urllib.request
import json
origin_dest = []
featurelist = []
if self.dlg.inputpoint.isChecked():
vp_layer = self.dlg.point.currentLayer()
countfeat = vp_layer.featureCount()
else:
vp_layer = iface.activeLayer()
vp_layer.commitChanges()
countfeat = vp_layer.featureCount()
result = processing.run(
"native:addautoincrementalfield", {
'INPUT': vp_layer,
'FIELD_NAME': 'id',
'START': 1,
'GROUP_FIELDS': [],
'SORT_EXPRESSION': '\"id\"',
'SORT_ASCENDING': True,
'SORT_NULLS_FIRST': False,
'OUTPUT': 'memory:{0}'.format(self.dlg.route_id.text())
})
QgsProject.instance().removeMapLayer(vp_layer)
vp_layer = result['OUTPUT']
QgsProject.instance().addMapLayer(vp_layer)
features = vp_layer.getFeatures()
points = []
pointdist = []
waypoints = []
# if vp_layer.featureCount() == 2:
for feature in vp_layer.getFeatures():
point = feature.geometry().asPoint()
xpoint = point.x()
ypoint = point.y()
Qpoint = QgsPointXY(xpoint, ypoint)
points.append(Qpoint)
distcheck = 0
if self.dlg.direction.currentText() == 'Start->End':
# for i in points:
# distance = QgsDistanceArea()
# Qpoint1 = i
# for j in points:
# Qpoint2 = j
# dist = distance.measureLine(Qpoint1, Qpoint2)
# pointdist.append(dist)
# if dist > distcheck:
# distcheck = dist
self.origin = points[0]
self.destination = points[countfeat - 1]
# print('End->Start', self.origin, self.destination)
elif self.dlg.direction.currentText() == 'End->Start':
# for i in points:
# distance = QgsDistanceArea()
# Qpoint1 = i
# for j in points:
# Qpoint2 = j
# dist = distance.measureLine(Qpoint1, Qpoint2)
# pointdist.append(dist)
# if dist > distcheck:
# distcheck = dist
self.origin = points[countfeat - 1]
self.destination = points[0]
# print('Start->End', self.origin, self.destination)
# print(vp_layer.featureCount())
if vp_layer.featureCount() > 3:
for i in range(countfeat - 1):
if i != 0 and i != countfeat - 1:
if self.dlg.direction.currentText() == 'Start->End':
if len(waypoints) < 1:
waypoints.append('optimize:true|via:' +
str(points[i].y()) + ',' +
str(points[i].x()))
else:
waypoints.append('via:' + str(points[i].y()) +
',' + str(points[i].x()))
elif self.dlg.direction.currentText() == 'End->Start':
if len(waypoints) < 1:
waypoints.append(
'optimize:true|via:' +
str(points[countfeat - i].y()) + ',' +
str(points[countfeat - i].x()))
else:
waypoints.append(
'via:' + str(points[countfeat - i].y()) +
',' + str(points[countfeat - i].x()))
print('|'.join(waypoints))
elif vp_layer.featureCount() == 3:
for i in points:
if i != self.origin and i != self.destination:
waypoints.append('optimize:true|via:' + str(i.y()) +
',' + str(i.x()))
else:
pass
# print(waypoints[0], 'waypoints')
# print(distcheck, 'dist')
# print(pointdist, 'pointdist')
# print(origin.x(),origin.y(), destination.x(),destination.y(), 'origin_dest')
# vp_layer.select(origin)
# vp_layer.select(destination)
for feature in vp_layer.getFeatures():
geometry = feature.geometry()
origin_dest.append(
{geometry.asPoint().y(),
geometry.asPoint().x()})
# print(origin_dest)
endpoint = 'https://maps.googleapis.com/maps/api/directions/json?'
APIkey = self.dlg.api.text()
# mode = 'driving'
origin_str = self.origin.y(), self.origin.x()
destination_str = self.destination.y(), self.destination.x()
# departure_time = (self.dlg.timeEdit.time().hour()*3600 + self.dlg.timeEdit.time().minute()*60+ self.dlg.timeEdit.time().second())
# print(departure_time)
import time
import datetime
# departure = self.totimestamp(self.dlg.timeEdit.dateTime())
if self.dlg.nowtime.isChecked():
departure = 'now'
else:
departure = self.dlg.timeEdit.dateTime().toSecsSinceEpoch()
print(departure)
if vp_layer.featureCount() > 3:
if self.dlg.avoid.currentText() == 'None':
nav_request = 'origin={0},{1}&destination={2},{3}&waypoints={4}&departure_time={5}&mode={6}&model={7}&key={8}'.format(
self.origin.y(), self.origin.x(), self.destination.y(),
self.destination.x(), '|'.join(waypoints), departure,
self.dlg.mode.currentText(),
self.dlg.model.currentText(), api_key)
else:
nav_request = 'origin={0},{1}&destination={2},{3}&waypoints={4}&departure_time={5}&avoid={6}&mode={7}&model={8}&key={9}'.format(
self.origin.y(), self.origin.x(), self.destination.y(),
self.destination.x(), '|'.join(waypoints), departure,
self.dlg.avoid.currentText(),
self.dlg.mode.currentText(),
self.dlg.model.currentText(), api_key)
elif vp_layer.featureCount() == 3:
if self.dlg.avoid.currentText() == 'None':
nav_request = 'origin={0},{1}&destination={2},{3}&waypoints={4}&departure_time={5}&mode={6}&model={7}&key={8}'.format(
self.origin.y(), self.origin.x(), self.destination.y(),
self.destination.x(), waypoints[0], departure,
self.dlg.mode.currentText(),
self.dlg.model.currentText(), api_key)
else:
nav_request = 'origin={0},{1}&destination={2},{3}&waypoints={4}&departure_time={5}&avoid={6}&mode={7}&model={8}&key={9}'.format(
self.origin.y(), self.origin.x(), self.destination.y(),
self.destination.x(), waypoints[0], departure,
self.dlg.avoid.currentText(),
self.dlg.mode.currentText(),
self.dlg.model.currentText(), api_key)
else:
if self.dlg.avoid.currentText() == 'None':
nav_request = 'origin={0},{1}&destination={2},{3}&departure_time={4}&mode={5}&model={6}&key={7}'.format(
self.origin.y(), self.origin.x(), self.destination.y(),
self.destination.x(), departure,
self.dlg.mode.currentText(),
self.dlg.model.currentText(), api_key)
# print(nav_request)
else:
nav_request = 'origin={0},{1}&destination={2},{3}&departure_time{4}&avoid={5}&mode={6}&model={7}&key={8}'.format(
self.origin.y(), self.origin.x(), self.destination.y(),
self.destination.x(), departure,
self.dlg.avoid.currentText(),
self.dlg.mode.currentText(),
self.dlg.model.currentText(), api_key)
request = endpoint + nav_request
print(request)
response = urllib.request.urlopen(request).read()
directions = json.loads(response)
keys = directions.keys()
# print(keys)
# print(directions['error_message'], directions['routes'])
routes = directions['routes']
legs = routes[0]['legs']
line = routes[0]['overview_polyline']
# print(routes)
points = polyline.decode(line['points'])
self.route_layer = QgsVectorLayer(
"Point?crs=EPSG:4326&field=route_id:String(100)&field=distance:String(100)&field=time:String(100)&field=ascending/descending:String(100)&field=departure_time:String(100)&field=roads_to_avoid:String(100)&field=traffic_model:String(100)",
"route_points", "memory")
provider = self.route_layer.dataProvider()
# QgsProject.instance().addMapLayer(self.route_layer)
if len(legs[0]['duration']['text'].split(' ')) == 2:
duration1 = legs[0]['duration']['text'].split(' ')
print(duration1, 'dur')
duration = duration1[0]
else:
duration1 = legs[0]['duration']['text'].split(' ')
print(duration1, 'dur1')
duration = str((int(duration1[0]) * 60) + int(duration1[2]))
self.route_layer.startEditing()
route_attrib = [
self.dlg.route_id.text(),
legs[0]['distance']['text'].split(' ')[0], duration,
self.dlg.direction.currentText(),
(self.dlg.timeEdit.dateTime()),
self.dlg.avoid.currentText(),
self.dlg.model.currentText()
]
# print((self.dlg.timeEdit.time()))
# print(route_attrib)
for i in points:
outelem = QgsFeature(self.route_layer.fields())
outelem.setGeometry(
QgsGeometry.fromPointXY(QgsPointXY(i[1], i[0])))
outelem.setFields(self.route_layer.fields())
outelem.setAttributes(route_attrib)
featurelist.append(outelem)
# print(outelem)
self.route_layer.dataProvider().addFeatures(featurelist)
self.route_layer.commitChanges()
result = processing.run(
"qgis:pointstopath", {
'INPUT': self.route_layer,
'ORDER_FIELD': 'route_id',
'GROUP_FIELD': None,
'DATE_FORMAT': '',
'OUTPUT': 'memory:'
})
if not self.dlg.checkBox.isChecked():
route = QgsVectorLayer(
"Linestring?crs=EPSG:4326&field=route_id:String(100)&field=distance(km):String(100)&field=time(min):String(100)&field=ascending/descending:String(100)&field=departure_time:String(100)&field=duration_in_traffic(min):String(100)&field=roads_to_avoid:String(100)&field=traffic_model:String(100)&field=no_of_nodes:String(100)",
"route", "memory")
else:
# print(self.dlg.route_id.text(), route_attrib2)
route = self.dlg.layer.currentLayer()
fields = route.dataProvider().fields()
field_name = [field.name() for field in fields]
# line_layer = QgsVectorLayer(result['OUTPUT'], 'route')
featurelist2 = []
# if self.dlg.mode.currentText() not in ['walking', 'bicycling', 'transit']:
if 'duration_in_traffic' in legs[0].keys():
if len(legs[0]['duration']['text'].split(' ')) == 2:
duration1 = legs[0]['duration_in_traffic']['text'].split(
' ')
print(duration1, 'dur12')
duration_in_traffic = duration1[0]
else:
duration1 = legs[0]['duration_in_traffic']['text'].split(
' ')
print(duration1, 'dur13')
duration_in_traffic = str((int(duration1[0]) * 60) +
int(duration1[2]))
if 'fid' in field_name:
route_attrib2 = [
route.featureCount(),
self.dlg.route_id.text(),
legs[0]['distance']['text'].split(' ')[0], duration,
self.dlg.direction.currentText(),
(self.dlg.timeEdit.dateTime()), duration_in_traffic,
self.dlg.avoid.currentText(),
self.dlg.model.currentText(),
str(self.route_layer.featureCount())
]
else:
route_attrib2 = [
self.dlg.route_id.text(),
legs[0]['distance']['text'].split(' ')[0], duration,
self.dlg.direction.currentText(),
(self.dlg.timeEdit.dateTime()), duration_in_traffic,
self.dlg.avoid.currentText(),
self.dlg.model.currentText(),
str(self.route_layer.featureCount())
]
else:
if 'fid' in field_name:
route_attrib2 = [
route.featureCount(),
self.dlg.route_id.text(),
legs[0]['distance']['text'].split(' ')[0], duration,
self.dlg.direction.currentText(),
(self.dlg.timeEdit.dateTime()), 'None',
self.dlg.avoid.currentText(),
self.dlg.model.currentText(),
str(self.route_layer.featureCount())
]
else:
route_attrib2 = [
self.dlg.route_id.text(),
legs[0]['distance']['text'].split(' ')[0], duration,
self.dlg.direction.currentText(),
(self.dlg.timeEdit.dateTime()), duration_in_traffic,
self.dlg.avoid.currentText(),
self.dlg.model.currentText(),
str(self.route_layer.featureCount())
]
# print(field_name)
# if 'fid' in field_name:
# # route.startEditing()
# # print(route.dataProvider().fieldNameIndex('fid'))
# # route.dataProvider().deleteAttributes([route.dataProvider().fieldNameIndex('fid')])
# # route.updateFields()
# # field_name = [field.name() for field in fields]
# # print(field_name)
#
# route_attrib2 = [route.featureCount(), self.dlg.route_id.text(), legs[0]['distance']['text'].split(' ')[0], duration, self.dlg.direction.currentText(),(self.dlg.timeEdit.dateTime()),'None',self.dlg.avoid.currentText(), self.dlg.model.currentText(), str(self.route_layer.featureCount())]
# else:
# pass
provider = route.dataProvider()
route.startEditing()
request = QgsFeatureRequest()
# set order by field
clause = QgsFeatureRequest.OrderByClause('route_id',
ascending=False)
orderby = QgsFeatureRequest.OrderBy([clause])
request.setOrderBy(orderby)
fields = route.dataProvider().fields()
field_name = [field.name() for field in fields]
for feature in result['OUTPUT'].getFeatures():
outelem = QgsFeature(route.fields())
outelem.setGeometry(feature.geometry())
outelem.setFields(route.fields())
if 'fid' not in field_name:
outelem.setAttributes(route_attrib2)
else:
for index, field in enumerate(field_name):
if field != 'fid':
print(field, route_attrib2[index])
outelem[field] = route_attrib2[index]
featurelist2.append(outelem)
route.dataProvider().addFeatures(featurelist2)
# route.updateFeature(feature)
route.commitChanges()
# QgsProject.instance().addMapLayer(route)
if route.featureCount() == 1:
file_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "route_style.qml"))
route.loadNamedStyle(file_path)
else:
# result_del = processing.run("qgis:deletecolumn", {
# 'INPUT': route,
# 'COLUMN': ['gid'], 'OUTPUT': 'memory:'})
# QgsProject.instance().addMapLayer(result_del['OUTPUT'])
# result = processing.run("native:addautoincrementalfield",
# {'INPUT': result_del['OUTPUT'],
# 'FIELD_NAME': 'gid', 'START': 1, 'GROUP_FIELDS': [],
# 'SORT_EXPRESSION': '',
# 'SORT_ASCENDING': False, 'SORT_NULLS_FIRST': False, 'OUTPUT': 'memory:route'})
#
# QgsProject.instance().removeMapLayer(route)
# route = result['OUTPUT']
QgsProject.instance().addMapLayer(route)
# provide file name index and field's unique values
# fni = route.dataProvider().fieldNameIndex('route_id')
# unique_values = route.uniqueValues(fni)
# fni2 = route.dataProvider().fieldNameIndex('route_id')
# unique_values2 = route.uniqueValues(fni2)
# unique_values2 = sorted(unique_values2)
unique_values2 = []
unique_values = []
request = QgsFeatureRequest()
# set order by field
clause = QgsFeatureRequest.OrderByClause('route_id',
ascending=False)
orderby = QgsFeatureRequest.OrderBy([clause])
request.setOrderBy(orderby)
for feature in route.getFeatures():
attrib = feature.attributes()
unique_values2.append(attrib[
route.dataProvider().fieldNameIndex('route_id')])
unique_values.append(attrib[
route.dataProvider().fieldNameIndex('route_id')])
from random import randrange
# fill categories
categories = []
# print(unique_values)
# unique_values = sorted(unique_values)
print(unique_values, unique_values2)
for index, unique_value in enumerate(unique_values):
# initialize the default symbol for this geometry type
# symbol = QgsSymbol.defaultSymbol(route.geometryType())
# symbol = QgsSymbol.Symbol().setShape(QgsSimpleMarkerSymbolLayerBase.Star
# symbol.appendSymbolLayer(symbol_layer)
# configure a symbol layer
# sym = route.renderer().symbol()
# double headed
symbol = QgsSymbol.defaultSymbol(route.geometryType())
# double headed
sym_layer = QgsArrowSymbolLayer.create({
"arrow_width":
"1",
"arrow_start_width":
"1",
"head_length":
"1.5",
"head_thickness":
"1.5",
"head_type":
"0",
"arrow_type":
"0",
"is_curved":
"0",
})
fill_sym = QgsFillSymbol.createSimple({
"color":
'%d, %d, %d' % (randrange(0, 256), randrange(
0, 256), randrange(0, 256))
})
sym_layer.setSubSymbol(fill_sym)
symbol.changeSymbolLayer(0, sym_layer)
# layer_style = {}
# layer_style['color'] = '%d, %d, %d' % (randrange(0, 256), randrange(0, 256), randrange(0, 256))
# layer_style['outline'] = '#FF0000'
# # layer_style['width'] = '7.6'
# symbol_layer = QgsSimpleFillSymbolLayer.create(layer_style)
# replace default symbol layer with the configured one
# if symbol_layer is not None:
# symbol.changeSymbolLayer(0, symbol_layer)
# symbol.setWidth(0.66)
# create renderer object
category = QgsRendererCategory(unique_value, symbol,
str(unique_values2[index]))
# entry for the list of category items
categories.append(category)
# create renderer object
renderer = QgsCategorizedSymbolRenderer('route_id', categories)
# assign the created renderer to the layer
if renderer is not None:
route.setRenderer(renderer)
route.triggerRepaint()
ltl = QgsProject.instance().layerTreeRoot().findLayer(
route.id())
ltm = iface.layerTreeView()
# ltm.sortItems(0, Qt.AscendingOrder)
# view = iface.layerTreeView()
# ltm.model().AllowNodeReorder()
index_newfeat = ltm.model().index(0, 0)
node = ltm.model().index2node(index_newfeat)
nodes = ltm.model().layerLegendNodes(node)
legendNodes = ltm.model().layerLegendNodes(ltl)
legend_dict = {}
legend_dict[node.name()] = legendNodes
# print(legend_dict)
ltm.setSortingEnabled(True)
ltm.sortByColumn(0, Qt.DescendingOrder)
for index, ln in enumerate(legendNodes):
if index + 1 != route.featureCount():
ln.setData(Qt.Unchecked, Qt.CheckStateRole)
# index_newfeat = ltm.model().index(route.featureCount()-1, 0)
# print(index_newfeat)
# node = ltm.model().index2node(index_newfeat)
# print(node)
# nodes = ltm.model().layerLegendNodes(node)
# # layer_and_nodes[n.name()] = nodes
# # print(layer_and_nodes)
# # legend_get = ltm.model().index2legendNode(nodes)
# print(nodes)
# print(index, ln)
# print(index, ltm.model().legendRootIndex(ln), ltm.model().legendNode2index(ln), ln, index_newfeat)
# if index+1 != int(self.dlg.route_id.text()):
# ln.setData(Qt.Checked, Qt.CheckStateRole)
if not self.dlg.checkBox.isChecked():
if self.dlg.output.text() != '':
path = self.dlg.output.text()
QgsVectorFileWriter.writeAsVectorFormat(
route, path, 'UTF-8', route.crs(), 'ESRI Shapefile')
# layer = QgsProject.instance().layerTreeRoot().findLayer(route.id())
# print(layer.name())
output = self.dlg.output.text().split('/')
route_path = QgsVectorLayer(
path, output[len(output) - 1].split('.')[0])
QgsProject.instance().addMapLayer(route_path)
else:
QgsProject.instance().addMapLayer(route)
listselect = []
for index, feature in enumerate(route.getFeatures()):
if index + 1 == route.featureCount():
listselect.append(feature.id())
route.select(listselect)
iface.actionZoomToSelected().trigger()
except Exception as e:
alert = QMessageBox()
alert.setWindowTitle('Alert')
if self.dlg.mode.currentText() in [
'walking', 'bicycling', 'transit'
]:
alert.setText(
str(e) + '\nRoute not available for selected mode.')
else:
alert.setText(str(e))
result = alert.exec_()
print(e)
def exportLayers(iface, layers, folder, precision, optimize, popupField, json,
restrictToExtent, extent, feedback):
canvas = iface.mapCanvas()
epsg4326 = QgsCoordinateReferenceSystem("EPSG:4326")
layersFolder = os.path.join(folder, "layers")
QDir().mkpath(layersFolder)
for count, (layer, encode2json,
popup) in enumerate(zip(layers, json, popupField)):
if (layer.type() == layer.VectorLayer
and (layer.providerType() != "WFS" or encode2json)):
feedback.showFeedback("Exporting %s to JSON..." % layer.name())
cleanLayer = writeTmpLayer(layer, popup, restrictToExtent, iface,
extent)
fields = layer.pendingFields()
for field in fields:
exportImages(layer, field.name(), layersFolder + "/tmp.tmp")
if is25d(layer, canvas, restrictToExtent, extent):
provider = cleanLayer.dataProvider()
provider.addAttributes([
QgsField("height", QVariant.Double),
QgsField("wallColor", QVariant.String),
QgsField("roofColor", QVariant.String)
])
cleanLayer.updateFields()
fields = cleanLayer.pendingFields()
renderer = layer.rendererV2()
renderContext = QgsRenderContext.fromMapSettings(
canvas.mapSettings())
feats = layer.getFeatures()
context = QgsExpressionContext()
context.appendScope(
QgsExpressionContextUtils.layerScope(layer))
expression = QgsExpression('eval(@qgis_25d_height)')
heightField = fields.indexFromName("height")
wallField = fields.indexFromName("wallColor")
roofField = fields.indexFromName("roofColor")
renderer.startRender(renderContext, fields)
cleanLayer.startEditing()
for feat in feats:
context.setFeature(feat)
height = expression.evaluate(context)
if isinstance(renderer, QgsCategorizedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
catIndex = renderer.categoryIndexForValue(attrValue)
categories = renderer.categories()
symbol = categories[catIndex].symbol()
elif isinstance(renderer, QgsGraduatedSymbolRendererV2):
classAttribute = renderer.classAttribute()
attrValue = feat.attribute(classAttribute)
ranges = renderer.ranges()
for range in ranges:
if (attrValue >= range.lowerValue()
and attrValue <= range.upperValue()):
symbol = range.symbol().clone()
else:
symbol = renderer.symbolForFeature2(
feat, renderContext)
sl1 = symbol.symbolLayer(1)
sl2 = symbol.symbolLayer(2)
wallColor = sl1.subSymbol().color().name()
roofColor = sl2.subSymbol().color().name()
provider.changeAttributeValues({
feat.id() + 1: {
heightField: height,
wallField: wallColor,
roofField: roofColor
}
})
cleanLayer.commitChanges()
renderer.stopRender(renderContext)
sln = safeName(cleanLayer.name()) + unicode(count)
tmpPath = os.path.join(layersFolder, sln + ".json")
path = os.path.join(layersFolder, sln + ".js")
options = []
if precision != "maintain":
options.append("COORDINATE_PRECISION=" + unicode(precision))
QgsVectorFileWriter.writeAsVectorFormat(cleanLayer,
tmpPath,
"utf-8",
epsg4326,
'GeoJson',
0,
layerOptions=options)
with open(path, "w") as f:
f.write("var %s = " % ("geojson_" + sln))
with open(tmpPath, "r") as f2:
for line in f2:
if optimize:
line = line.strip("\n\t ")
line = removeSpaces(line)
f.write(line)
os.remove(tmpPath)
elif (layer.type() == layer.RasterLayer
and layer.providerType() != "wms"):
exportRaster(layer, count, layersFolder, feedback)
feedback.completeStep()
