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()