def export( self, path, driver_name="ESRI Shapefile", overwrite=True, target_crs_id=None, ): """Write layer to file. Args: path (str): Path of the output file driver_name (str): Defaults to ESRI Shapefile. overwrite (bool): Defaults to True target_crs_id (int): Defaults to source CRS """ if target_crs_id is None: target_crs = self.crs() else: target_crs = QgsCoordinateReferenceSystem.fromEpsgId(target_crs_id) if os.path.exists(path) and overwrite: if driver_name == "ESRI Shapefile": QgsVectorFileWriter.deleteShapeFile(path) else: os.remove(path) result = self.writeAsVectorFormat(path, driver_name, target_crs) try: return result[0] == QgsVectorFileWriter.NoError except TypeError: return result == QgsVectorFileWriter.NoError
def overwrite_layers_merged(project_path): root = QgsProject.instance().layerTreeRoot() group = root.findGroup(PROJECT_GROUP[2]) operators_path = join(project_path, PROJECT_GROUP[2]) operators_content = get_elements_name(operators_path, True, None) layers = get_layers_from_folder('SHP_') if layers is not None: for i_op, item in enumerate(operators_content): # load vectors shp_path = join(operators_path, item, 'SHP') for shp_file in glob.glob(join(shp_path, '*.shp')): layer_name = basename(shp_file).replace(".shp", "") if '_' not in layer_name: if group is not None: for child in group.children(): QgsProject.instance().removeMapLayer(child.layerId()) root.removeChildNode(group) if layers[i_op].isValid(): QgsVectorFileWriter.deleteShapeFile(shp_file) export_layer_as(layers[i_op], layer_name, "ESRI Shapefile", dirname(shp_file)) else: delete_unused_folder(project_path) load_unloaded_data(project_path) else: return
def create_layer(self, parameters, name, is_memory, dest_crs, layer_style=None): save_as = parameters.file_path file_format = parameters.file_format # save paramaters serialized = base64.b64encode(parameters.serialize(with_style=False, with_geometry=False)) # save geometry layer = QgsVectorLayer("MultiPolygon?crs=%s" % dest_crs.authid(), name, "memory") pr = layer.dataProvider() layer.startEditing() layer.addAttribute(QgsField("params", QVariant.String)) fet1 = QgsFeature(0) fet1.setFields(layer.fields()) fet1.setAttribute("params", str(serialized)[2:-1]) fet1.setGeometry(parameters.geometry) pr.addFeatures([fet1]) layer.commitChanges() # copy layer style if layer_style is not None: self.set_layer_style(layer, layer_style) if is_memory: return layer if os.path.isfile(save_as): # delete first if already exists if save_as.endswith(".shp"): QgsVectorFileWriter.deleteShapeFile(save_as) else: os.unlink(save_as) # create the disk layer QgsMessageLog.logMessage("Mask saving '{}' as {}".format(save_as, file_format), 'Extensions') error = QgsVectorFileWriter.writeAsVectorFormat(layer, save_as, "System", dest_crs, file_format) if error == 0: nlayer = QgsVectorLayer(save_as, name, "ogr") if not nlayer.dataProvider().isValid(): return None if not nlayer.hasGeometryType(): return None # force CRS nlayer.setCrs(dest_crs) # copy layer style layer_style = self.get_layer_style(layer) self.set_layer_style(nlayer, layer_style) return nlayer else: raise RuntimeError(error) return None
def removeLayer(path_layer): # remove layer from TOC if already loaded basefile = os.path.basename(path_layer) diff_layer = os.path.splitext(basefile)[0] directory = os.path.dirname(path_layer) extensions = [ "shp", "shx", "dbf", "prj", "sbn", "sbx", "fbn", "fbx", "ain", "aih", "ixs", "mxs", "atx", "xml", "cpg", "qix" ] if len(QgsProject.instance().mapLayersByName(diff_layer)) > 0: lyr = QgsProject.instance().mapLayersByName(diff_layer)[0] print('removing layer1: ', lyr.id()) QgsProject.instance().removeMapLayer(lyr.id()) QgsVectorFileWriter.deleteShapeFile(path_layer)
def randomize(self, inLayer, outPath, minimum, design, value): outFeat = QgsFeature() outFeat.initAttributes(1) if design == self.tr("unstratified"): ext = inLayer.extent() if inLayer.type() == QgsMapLayer.RasterLayer: points = self.simpleRandom(int(value), ext, ext.xMinimum(), ext.xMaximum(), ext.yMinimum(), ext.yMaximum()) else: points = self.vectorRandom(int(value), inLayer, ext.xMinimum(), ext.xMaximum(), ext.yMinimum(), ext.yMaximum()) else: points, featErrors = self.loopThruPolygons(inLayer, value, design) if featErrors: if len(featErrors) >= 10: err_msg = "Too many features couldn't be calculated due to conversion error. " err_msg += "Please check out message log for more info." msgLogInstance = QgsMessageLog.instance() msgLogInstance.logMessage("WARNING - fTools: " + self.tr("Random Points")) msgLogInstance.logMessage( "The following feature ids should be checked.") for feat in featErrors: msgLogInstance.logMessage("Feature id: %d" % feat.id()) msgLogInstance.logMessage("End of features to be checked.") else: features_ids = [] for feat in featErrors: features_ids.append(unicode(feat.id())) erroneous_ids = ', '.join(features_ids) err_msg = "The following features IDs couldn't be calculated due to conversion error: %s" % erroneous_ids self.iface.messageBar().pushMessage("Errors", err_msg) if len(points): crs = self.iface.mapCanvas().mapRenderer().destinationCrs() if not crs.isValid(): crs = None fields = QgsFields() fields.append(QgsField("ID", QVariant.Int)) outFeat.setFields(fields) check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPoint, crs) idVar = 0 count = 70.00 add = (100.00 - 70.00) / len(points) for i in points: outFeat.setGeometry(i) outFeat.setAttribute(0, idVar) writer.addFeature(outFeat) idVar = idVar + 1 count = count + add self.progressBar.setValue(count) del writer return True return False
def accept(self): if self.inputFiles is None: workDir = QDir(self.leInputDir.text()) workDir.setFilter(QDir.Files | QDir.NoSymLinks | QDir.NoDotAndDotDot) nameFilter = ["*.shp", "*.SHP"] workDir.setNameFilters(nameFilter) self.inputFiles = workDir.entryList() if len(self.inputFiles) == 0: QMessageBox.warning( self, self.tr("No shapefiles found"), self.tr("There are no shapefiles in this directory. Please select another one.")) self.inputFiles = None return if self.outFileName is None: QMessageBox.warning( self, self.tr("No output file"), self.tr("Please specify output file.")) return if self.chkListMode.isChecked(): files = self.leInputDir.text().split(";") baseDir = QFileInfo(files[0]).absolutePath() else: baseDir = self.leInputDir.text() # look for shapes with specified geometry type self.inputFiles = ftools_utils.getShapesByGeometryType(baseDir, self.inputFiles, self.cmbGeometry.currentIndex()) if self.inputFiles is None: QMessageBox.warning( self, self.tr("No shapefiles found"), self.tr("There are no shapefiles with the given geometry type. Please select an available geometry type.")) return self.progressFiles.setRange(0, len(self.inputFiles)) outFile = QFile(self.outFileName) if outFile.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.outFileName): QMessageBox.warning(self, self.tr("Delete error"), self.tr("Can't delete file %s") % (self.outFileName)) return if self.inEncoding is None: self.inEncoding = "System" self.btnOk.setEnabled(False) self.mergeThread = ShapeMergeThread(baseDir, self.inputFiles, self.inEncoding, self.outFileName, self.encoding) QObject.connect(self.mergeThread, SIGNAL("rangeChanged( PyQt_PyObject )"), self.setFeatureProgressRange) QObject.connect(self.mergeThread, SIGNAL("checkStarted()"), self.setFeatureProgressFormat) QObject.connect(self.mergeThread, SIGNAL("checkFinished()"), self.resetFeatureProgressFormat) QObject.connect(self.mergeThread, SIGNAL("fileNameChanged( PyQt_PyObject )"), self.setShapeProgressFormat) QObject.connect(self.mergeThread, SIGNAL("featureProcessed()"), self.featureProcessed) QObject.connect(self.mergeThread, SIGNAL("shapeProcessed()"), self.shapeProcessed) QObject.connect(self.mergeThread, SIGNAL("processingFinished()"), self.processingFinished) QObject.connect(self.mergeThread, SIGNAL("processingInterrupted()"), self.processingInterrupted) self.btnClose.setText(self.tr("Cancel")) QObject.disconnect(self.buttonBox, SIGNAL("rejected()"), self.reject) QObject.connect(self.btnClose, SIGNAL("clicked()"), self.stopProcessing) self.mergeThread.start()
def compute(self, inPoly, inLns, inField, outPath, progressBar): polyLayer = ftools_utils.getVectorLayerByName(inPoly) lineLayer = ftools_utils.getVectorLayerByName(inLns) polyProvider = polyLayer.dataProvider() lineProvider = lineLayer.dataProvider() if polyProvider.crs() != lineProvider.crs(): QMessageBox.warning( self, self.tr("CRS warning!"), self. tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results." )) fieldList = ftools_utils.getFieldList(polyLayer) index = polyProvider.fieldNameIndex(unicode(inField)) if index == -1: index = polyProvider.fields().count() fieldList.append( QgsField(unicode(inField), QVariant.Double, "real", 24, 15, self.tr("length field"))) sRs = polyProvider.crs() inFeat = QgsFeature() inFeatB = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() outGeom = QgsGeometry() distArea = QgsDistanceArea() start = 0.00 add = 100.00 / polyProvider.featureCount() check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, polyProvider.geometryType(), sRs) spatialIndex = ftools_utils.createIndex(lineProvider) polyFit = polyProvider.getFeatures() while polyFit.nextFeature(inFeat): inGeom = QgsGeometry(inFeat.geometry()) atMap = inFeat.attributes() lineList = [] length = 0 lineList = spatialIndex.intersects(inGeom.boundingBox()) if len(lineList) > 0: check = 0 else: check = 1 if check == 0: for i in lineList: lineProvider.getFeatures(QgsFeatureRequest().setFilterFid( int(i))).nextFeature(inFeatB) tmpGeom = QgsGeometry(inFeatB.geometry()) if inGeom.intersects(tmpGeom): outGeom = inGeom.intersection(tmpGeom) length = length + distArea.measure(outGeom) outFeat.setGeometry(inGeom) atMap.append(length) outFeat.setAttributes(atMap) writer.addFeature(outFeat) start = start + 1 progressBar.setValue(start * (add)) del writer
def run(self): self.mutex.lock() self.stopMe = 0 self.mutex.unlock() interrupted = False outPath = self.outDir if outPath.find("\\") != -1: outPath.replace("\\", "/") if not outPath.endswith("/"): outPath = outPath + "/" provider = self.layer.dataProvider() index = provider.fieldNameIndex(self.field) unique = ftools_utils.getUniqueValues(provider, int(index)) baseName = unicode(outPath + self.layer.name() + "_" + self.field + "_") fieldList = ftools_utils.getFieldList(self.layer) sRs = provider.crs() geom = self.layer.wkbType() inFeat = QgsFeature() self.emit(SIGNAL("rangeCalculated(PyQt_PyObject)"), len(unique)) for i in unique: check = QFile(baseName + "_" + unicode(i).strip() + ".shp") fName = check.fileName() if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(fName): self.errors.append(fName) continue writer = QgsVectorFileWriter(fName, self.encoding, fieldList, geom, sRs) fit = provider.getFeatures() while fit.nextFeature(inFeat): atMap = inFeat.attributes() if atMap[index] == i: writer.addFeature(inFeat) del writer self.emit(SIGNAL("valueProcessed()")) self.mutex.lock() s = self.stopMe self.mutex.unlock() if s == 1: interrupted = True break if not interrupted: self.emit(SIGNAL("processFinished( PyQt_PyObject )"), self.errors) else: self.emit(SIGNAL("processInterrupted()"))
def accept(self): if not self.cmbInputLayer.currentText(): QMessageBox.warning(self, self.tr("Warning"), self.tr("Please specify an input layer")) return vLayer = ftools_utils.getVectorLayerByName( self.cmbInputLayer.currentText()) self.btnOk.setEnabled(False) if self.chkWriteShapefile.isChecked(): outFileName = self.edOutputFile.text() outFile = QFile(outFileName) if outFile.exists(): if not QgsVectorFileWriter.deleteShapeFile(outFileName): QMessageBox.warning( self, self.tr("Delete error"), self.tr("Can't delete file %s") % (outFileName)) self.btnOk.setEnabled(False) return self.workThread = GeomThread(self.myFunction, vLayer, self.chkUseSelection.isChecked(), self.spnTolerance.value(), True, outFileName, self.encoding) else: res = QMessageBox.warning( self, self.tr("Warning"), self. tr("Currently QGIS doesn't allow simultaneous access from " "different threads to the same datasource. Make sure your layer's " "attribute tables are closed. Continue?"), QMessageBox.Yes | QMessageBox.No) if res == QMessageBox.No: self.btnOk.setEnabled(False) return self.workThread = GeomThread(self.myFunction, vLayer, self.chkUseSelection.isChecked(), self.spnTolerance.value(), False, None, None) QObject.connect(self.workThread, SIGNAL("rangeCalculated( PyQt_PyObject )"), self.setProgressRange) QObject.connect(self.workThread, SIGNAL("featureProcessed()"), self.featureProcessed) QObject.connect(self.workThread, SIGNAL("processingFinished( PyQt_PyObject )"), self.processFinished) QObject.connect(self.workThread, SIGNAL("processingInterrupted()"), self.processInterrupted) self.btnClose.setText(self.tr("Cancel")) QObject.disconnect(self.buttonBox, SIGNAL("rejected()"), self.reject) QObject.connect(self.btnClose, SIGNAL("clicked()"), self.stopProcessing) self.workThread.start()
def run(self): self.mutex.lock() self.stopMe = 0 self.mutex.unlock() interrupted = False outPath = self.outDir if outPath.find("\\") != -1: outPath.replace("\\", "/") if not outPath.endswith("/"): outPath = outPath + "/" provider = self.layer.dataProvider() index = provider.fieldNameIndex(self.field) unique = ftools_utils.getUniqueValues(provider, int(index)) baseName = unicode( outPath + self.layer.name() + "_" + self.field + "_" ) fieldList = ftools_utils.getFieldList(self.layer) sRs = provider.crs() geom = self.layer.wkbType() inFeat = QgsFeature() self.emit(SIGNAL("rangeCalculated(PyQt_PyObject)"), len(unique)) for i in unique: check = QFile(baseName + "_" + unicode(i).strip() + ".shp") fName = check.fileName() if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(fName): self.errors.append( fName ) continue writer = QgsVectorFileWriter(fName, self.encoding, fieldList, geom, sRs) fit = provider.getFeatures() while fit.nextFeature(inFeat): atMap = inFeat.attributes() if atMap[index] == i: writer.addFeature(inFeat) del writer self.emit(SIGNAL("valueProcessed()")) self.mutex.lock() s = self.stopMe self.mutex.unlock() if s == 1: interrupted = True break if not interrupted: self.emit(SIGNAL("processFinished( PyQt_PyObject )"), self.errors) else: self.emit(SIGNAL("processInterrupted()"))
def deleteVectorFile(self, fileName): if QgsVectorFileWriter.deleteShapeFile(fileName) is False: QMessageBox.warning(self.iface.mainWindow(), "VoGIS-Profiltool", QApplication.translate("code", "Konnte vorhandene Datei nicht löschen") + ": " + fileName ) return False else: return True
def remove_generador_temp_files(self, message=False): """ Remove the Generador MMC's temporal files """ # Sembla ser que hi ha un bug que impedeix esborrar els arxius .shp i .dbf si no es tanca i es torna # a obrir la finestra del plugin temp_list = os.listdir(GENERADOR_WORK_DIR) for temp in temp_list: if temp in TEMP_ENTITIES: try: QgsVectorFileWriter.deleteShapeFile( os.path.join(GENERADOR_WORK_DIR, temp)) except Exception as error: self.show_error_message( "No s'han pogut esborrar els arxius temporals.") QgsMessageLog.logMessage(error) return if message: self.show_success_message('Arxius temporals esborrats.')
def randomize(self, inLayer, outPath, minimum, design, value): outFeat = QgsFeature() outFeat.initAttributes(1) if design == self.tr("unstratified"): ext = inLayer.extent() if inLayer.type() == QgsMapLayer.RasterLayer: points = self.simpleRandom( int(value), ext, ext.xMinimum(), ext.xMaximum(), ext.yMinimum(), ext.yMaximum()) else: points = self.vectorRandom( int(value), inLayer, ext.xMinimum(), ext.xMaximum(), ext.yMinimum(), ext.yMaximum()) else: points, featErrors = self.loopThruPolygons(inLayer, value, design) if featErrors: if len(featErrors) >= 10: err_msg = "Too many features couldn't be calculated due to conversion error. " err_msg += "Please check out message log for more info." msgLogInstance = QgsMessageLog.instance() msgLogInstance.logMessage("WARNING - fTools: " + self.tr("Random Points")) msgLogInstance.logMessage("The following feature ids should be checked.") for feat in featErrors: msgLogInstance.logMessage("Feature id: %d" % feat.id()) msgLogInstance.logMessage("End of features to be checked.") else: features_ids = [] for feat in featErrors: features_ids.append(unicode(feat.id())) erroneous_ids = ', '.join(features_ids) err_msg = "The following features IDs couldn't be calculated due to conversion error: %s" % erroneous_ids self.iface.messageBar().pushMessage("Errors", err_msg) if len(points): crs = self.iface.mapCanvas().mapRenderer().destinationCrs() if not crs.isValid(): crs = None fields = QgsFields() fields.append(QgsField("ID", QVariant.Int)) outFeat.setFields(fields) check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPoint, crs) idVar = 0 count = 70.00 add = (100.00 - 70.00) / len(points) for i in points: outFeat.setGeometry(i) outFeat.setAttribute(0, idVar) writer.addFeature(outFeat) idVar = idVar + 1 count = count + add self.progressBar.setValue(count) del writer return True return False
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 exportLayerAsShp(self, layer, time, name="Apis_Export", groupName="Temp", styleName=None, parent=None): # check if layer has features to be exported if layer.hasFeatures(): # get previous directory saveDir = self.settings.value("APIS/working_dir", QDir.home().dirName()) # save file dialog layerName = QFileDialog.getSaveFileName( parent, u"SHP Datei Export Speichern", saveDir + "\\" + "{0}_{1}".format(name, time), "*.shp")[0] if layerName: check = QFile(layerName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(layerName): QMessageBox.warning( parent, "SHP Datei Export", u"Es ist nicht möglich die SHP Datei {0} zu überschreiben!" .format(layerName)) return error = QgsVectorFileWriter.writeAsVectorFormat( layer, layerName, "UTF-8", layer.crs(), "ESRI Shapefile") if error[0] == QgsVectorFileWriter.NoError: fof = FileOrFolder(parent=parent) if fof == 0 or fof == 2: # Shp Datei in QGIS laden if styleName: stylePath = self.stylesDir + self.__layers[ styleName]["style"] self.requestShapeFile(layerName, groupName=groupName, addToCanvas=True, stylePath=stylePath) if fof == 1 or fof == 2: # Ordner öffnen OpenFileOrFolder(os.path.split(layerName)[0]) else: QMessageBox.warning( self, "SHP Datei Export", u"Beim erstellen der SHP Datei ist ein Fehler aufgetreten: {0}" .format(error)) else: QMessageBox.warning( parent, "SHP Datei Export", u"Der zu exportierende Layer ({0}) hat keine Features.".format( layer.name())) return
def compute(self, inPoly, inLns, inField, outPath, progressBar): polyLayer = ftools_utils.getVectorLayerByName(inPoly) lineLayer = ftools_utils.getVectorLayerByName(inLns) polyProvider = polyLayer.dataProvider() lineProvider = lineLayer.dataProvider() if polyProvider.crs() != lineProvider.crs(): QMessageBox.warning(self, self.tr("CRS warning!"), self.tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results.")) fieldList = ftools_utils.getFieldList(polyLayer) index = polyProvider.fieldNameIndex(unicode(inField)) if index == -1: index = polyProvider.fields().count() fieldList.append(QgsField(unicode(inField), QVariant.Double, "real", 24, 15, self.tr("length field"))) sRs = polyProvider.crs() inFeat = QgsFeature() inFeatB = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() outGeom = QgsGeometry() distArea = QgsDistanceArea() start = 0.00 add = 100.00 / polyProvider.featureCount() check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, polyProvider.geometryType(), sRs) spatialIndex = ftools_utils.createIndex(lineProvider) polyFit = polyProvider.getFeatures() while polyFit.nextFeature(inFeat): inGeom = QgsGeometry(inFeat.geometry()) atMap = inFeat.attributes() lineList = [] length = 0 lineList = spatialIndex.intersects(inGeom.boundingBox()) if len(lineList) > 0: check = 0 else: check = 1 if check == 0: for i in lineList: lineProvider.getFeatures(QgsFeatureRequest().setFilterFid(int(i))).nextFeature(inFeatB) tmpGeom = QgsGeometry(inFeatB.geometry()) if inGeom.intersects(tmpGeom): outGeom = inGeom.intersection(tmpGeom) length = length + distArea.measure(outGeom) outFeat.setGeometry(inGeom) atMap.append(length) outFeat.setAttributes(atMap) writer.addFeature(outFeat) start = start + 1 progressBar.setValue(start * (add)) del writer
def runFinishedFromThread(self, success): self.testThread.stop() self.buttonOk.setEnabled(True) extra = "" if success == "math_error": QMessageBox.warning(self, self.tr("Geometry"), self.tr("Error processing specified tolerance!\nPlease choose larger tolerance...")) if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): QMessageBox.warning(self, self.tr("Geometry"), self.tr("Unable to delete incomplete shapefile.")) elif success == "attr_error": QMessageBox.warning(self, self.tr("Geometry"), self.tr("At least two features must have same attribute value!\nPlease choose another field...")) if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): QMessageBox.warning(self, self.tr("Geometry"), self.tr("Unable to delete incomplete shapefile.")) else: if success == "valid_error": extra = self.tr("One or more features in the output layer may have invalid " + "geometry, please check using the check validity tool\n") success = True self.cancel_close.setText("Close") QObject.disconnect(self.cancel_close, SIGNAL("clicked()"), self.cancelThread) if success: if (self.myFunction == 5 and self.chkWriteShapefile.isChecked()) or self.myFunction != 5: if self.addToCanvasCheck.isChecked(): addCanvasCheck = ftools_utils.addShapeToCanvas(unicode(self.shapefileName)) if not addCanvasCheck: QMessageBox.warning(self, self.tr("Geometry"), self.tr("Error loading output shapefile:\n%s") % (unicode(self.shapefileName))) self.populateLayers() else: QMessageBox.information(self, self.tr("Geometry"), self.tr("Created output shapefile:\n%s\n%s") % (unicode(self.shapefileName), extra)) else: QMessageBox.information(self, self.tr("Geometry"), self.tr("Layer '{0}' updated").format(self.inShape.currentText())) else: QMessageBox.warning(self, self.tr("Geometry"), self.tr("Error writing output shapefile."))
def runFinishedFromThread( self, success ): self.testThread.stop() self.buttonOk.setEnabled( True ) extra = "" if success == "math_error": QMessageBox.warning( self, self.tr( "Geometry" ), self.tr( "Error processing specified tolerance!\nPlease choose larger tolerance..." ) ) if not QgsVectorFileWriter.deleteShapeFile( self.shapefileName ): QMessageBox.warning( self, self.tr( "Geometry" ), self.tr( "Unable to delete incomplete shapefile." ) ) elif success == "attr_error": QMessageBox.warning( self, self.tr( "Geometry" ), self.tr( "At least two features must have same attribute value!\nPlease choose another field..." ) ) if not QgsVectorFileWriter.deleteShapeFile( self.shapefileName ): QMessageBox.warning( self, self.tr( "Geometry" ), self.tr( "Unable to delete incomplete shapefile." ) ) else: if success == "valid_error": extra = self.tr( "One or more features in the output layer may have invalid " + "geometry, please check using the check validity tool\n" ) success = True self.cancel_close.setText( "Close" ) QObject.disconnect( self.cancel_close, SIGNAL( "clicked()" ), self.cancelThread ) if success: if ( self.myFunction == 5 and self.chkWriteShapefile.isChecked() ) or self.myFunction != 5: if self.addToCanvasCheck.isChecked(): addCanvasCheck = ftools_utils.addShapeToCanvas(unicode(self.shapefileName)) if not addCanvasCheck: QMessageBox.warning( self, self.tr("Geometry"), self.tr( "Error loading output shapefile:\n%s" ) % ( unicode( self.shapefileName ) )) self.populateLayers() else: QMessageBox.information(self, self.tr("Geometry"),self.tr("Created output shapefile:\n%s\n%s" ) % ( unicode( self.shapefileName ), extra )) else: QMessageBox.information( self, self.tr( "Geometry" ), self.tr( "Layer '{0}' updated" ).format( self.inShape.currentText() ) ) else: QMessageBox.warning( self, self.tr( "Geometry" ), self.tr( "Error writing output shapefile." ) )
def run(self): """Create the output shapefile.""" if os.path.isdir(self.filmPath) and len(self.images) > 0: check = QFile(self.shpFile) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shpFile): self.iface.messageBar().pushMessage(u"Error", u"Die Datei existiert bereits und kann nicht überschrieben werden (Eventuell in QGIS geladen!).", level=Qgis.Critical, duration=10) return None # fields fields = QgsFields() fields.append(QgsField("bildnr", QVariant.Int)) fields.append(QgsField("lat", QVariant.Double)) fields.append(QgsField("lon", QVariant.Double)) fields.append(QgsField("alt", QVariant.Double)) writer = QgsVectorFileWriter(str(self.shpFile), "UTF-8", fields, QgsWkbTypes.Point, QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId), "ESRI Shapefile") mb = self.iface.messageBar().createMessage(u"EXIF", u"Die EXIF Daten (Geo Koordinaten und Höhe) werden aus den Bildern ausgelesen") progress = QProgressBar() progress.setMinimum(0) progress.setMaximum(0) progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) mb.layout().addWidget(progress) self.iface.messageBar().pushWidget(mb, Qgis.Info) hasFeatures = False for feature in self.iter_images_as_features(): writer.addFeature(feature) hasFeatures = True del writer if hasFeatures: self.iface.messageBar().clearWidgets() self.iface.messageBar().pushMessage(u"EXIF", u"Die Shape Datei wurde erfolgreich erstellt und in QGIS geladen!", level=Qgis.Success, duration=10) return self.shpFile else: QMessageBox.warning(None, "Bilder", u"Die vorhandenen Bilder enthalten keine GPS Information.") return None else: QMessageBox.warning(None, "Verzeichnis", u"Es wurde kein Bildverzeichnis für diesen Film gefunden.") return None
def regularize(self, bound, outPath, offset, value, gridType, inset, crs): area = bound.width() * bound.height() if offset: seed() if gridType: pointSpacing = value else: # Calculate grid spacing pointSpacing = sqrt(area / value) outFeat = QgsFeature() outFeat.initAttributes(1) fields = QgsFields() fields.append(QgsField("ID", QVariant.Int)) outFeat.setFields(fields) check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPoint, crs) idVar = 0 count = 10.00 add = 90.00 / (area / pointSpacing) y = bound.yMaximum() - inset while y >= bound.yMinimum(): x = bound.xMinimum() + inset while x <= bound.xMaximum(): if offset: pGeom = QgsGeometry().fromPoint( QgsPoint( uniform(x - (pointSpacing / 2.0), x + (pointSpacing / 2.0)), uniform(y - (pointSpacing / 2.0), y + (pointSpacing / 2.0)))) else: pGeom = QgsGeometry().fromPoint(QgsPoint(x, y)) if pGeom.intersects(bound): outFeat.setGeometry(pGeom) outFeat.setAttribute(0, idVar) writer.addFeature(outFeat) idVar = idVar + 1 x = x + pointSpacing count = count + add self.progressBar.setValue(count) y = y - pointSpacing del writer
def accept(self): if not self.cmbInputLayer.currentText(): QMessageBox.warning(self, self.tr("Warning"), self.tr("Please specify an input layer")) return vLayer = ftools_utils.getVectorLayerByName(self.cmbInputLayer.currentText()) self.btnOk.setEnabled(False) if self.chkWriteShapefile.isChecked(): outFileName = self.edOutputFile.text() outFile = QFile(outFileName) if outFile.exists(): if not QgsVectorFileWriter.deleteShapeFile(outFileName): QMessageBox.warning(self, self.tr("Delete error"), self.tr("Can't delete file %s") % (outFileName)) self.btnOk.setEnabled(False) return self.workThread = GeomThread(self.myFunction, vLayer, self.chkUseSelection.isChecked(), self.spnTolerance.value(), True, outFileName, self.encoding) else: res = QMessageBox.warning(self, self.tr("Warning"), self.tr( "Currently QGIS doesn't allow simultaneous access from " "different threads to the same datasource. Make sure your layer's " "attribute tables are closed. Continue?"), QMessageBox.Yes | QMessageBox.No) if res == QMessageBox.No: self.btnOk.setEnabled(False) return self.workThread = GeomThread(self.myFunction, vLayer, self.chkUseSelection.isChecked(), self.spnTolerance.value(), False, None, None) QObject.connect(self.workThread, SIGNAL("rangeCalculated( PyQt_PyObject )"), self.setProgressRange) QObject.connect(self.workThread, SIGNAL("featureProcessed()"), self.featureProcessed) QObject.connect(self.workThread, SIGNAL("processingFinished( PyQt_PyObject )"), self.processFinished) QObject.connect(self.workThread, SIGNAL("processingInterrupted()"), self.processInterrupted) self.btnClose.setText(self.tr("Cancel")) QObject.disconnect(self.buttonBox, SIGNAL("rejected()"), self.reject) QObject.connect(self.btnClose, SIGNAL("clicked()"), self.stopProcessing) self.workThread.start()
def accept(self): self.buttonOk.setEnabled(False) if self.inShape.currentText() == "": QMessageBox.information(self, self.tr("Eliminate"), self.tr("No input shapefile specified")) else: outFileName = self.outShape.text() if outFileName == "": QMessageBox.information( self, self.tr("Eliminate"), self.tr("Please specify output shapefile")) self.buttonOk.setEnabled(True) return None else: outFile = QFile(outFileName) if outFile.exists(): if not QgsVectorFileWriter.deleteShapeFile(outFileName): QMessageBox.warning( self, self.tr("Delete error"), self.tr("Can't delete file %s") % (outFileName)) self.buttonOk.setEnabled(True) return None outFileName = unicode(outFileName) inLayer = ftools_utils.getVectorLayerByName( unicode(self.inShape.currentText())) if inLayer.selectedFeatureCount() == 0: QMessageBox.information(self, self.tr("Eliminate"), self.tr("No selection in input layer")) else: self.progressBar.setValue(5) boundary = self.boundary.isChecked() self.eliminate(inLayer, boundary, self.progressBar, outFileName) self.progressBar.setValue(100) self.outShape.clear() self.progressBar.setValue(0) self.buttonOk.setEnabled(True)
def regularize(self, bound, outPath, offset, value, gridType, inset, crs): area = bound.width() * bound.height() if offset: seed() if gridType: pointSpacing = value else: # Calculate grid spacing pointSpacing = sqrt(area / value) outFeat = QgsFeature() outFeat.initAttributes(1) fields = QgsFields() fields.append( QgsField("ID", QVariant.Int) ) outFeat.setFields( fields ) check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPoint, crs) idVar = 0 count = 10.00 add = 90.00 / (area / pointSpacing) y = bound.yMaximum() - inset while y >= bound.yMinimum(): x = bound.xMinimum() + inset while x <= bound.xMaximum(): if offset: pGeom = QgsGeometry().fromPoint( QgsPoint( uniform(x - (pointSpacing / 2.0), x + (pointSpacing / 2.0)), uniform(y - (pointSpacing / 2.0), y + (pointSpacing / 2.0)) )) else: pGeom = QgsGeometry().fromPoint(QgsPoint(x, y)) if pGeom.intersects(bound): outFeat.setGeometry(pGeom) outFeat.setAttribute(0, idVar) writer.addFeature(outFeat) idVar = idVar + 1 x = x + pointSpacing count = count + add self.progressBar.setValue(count) y = y - pointSpacing del writer
def remove_result_layers(self, remove_all=False, delete_source=False): layers_to_remove = [ layer for layer, flag in settings.l_result_layers_to_remove if remove_all or flag ] ins = QgsMapLayerRegistry.instance() ##layers = ins.mapLayersByName() layers = self.iface.legendInterface().layers() for layer in layers: source = layer.source() if layer.name() in layers_to_remove: print_log("remove layer {}".format(layer.name()), "d") ins.removeMapLayer(layer.id()) if delete_source: pass # not sure if necessary result = QgsVectorFileWriter.deleteShapeFile(source) if not result: print_log( "Tool afgebroken! Kan resultaat ({}) niet verwijderen!" .format(source), "e", self.iface) return
def accept(self): self.buttonOk.setEnabled(False) if self.inShape.currentText() == "": QMessageBox.information(self, self.tr("Eliminate"), self.tr("No input shapefile specified")) else: outFileName = self.outShape.text() if outFileName == "": QMessageBox.information(self, self.tr("Eliminate"), self.tr("Please specify output shapefile")) self.buttonOk.setEnabled(True) return None else: outFile = QFile(outFileName) if outFile.exists(): if not QgsVectorFileWriter.deleteShapeFile(outFileName): QMessageBox.warning( self, self.tr("Delete error"), self.tr("Can't delete file %s") % (outFileName)) self.buttonOk.setEnabled(True) return None outFileName = unicode(outFileName) inLayer = ftools_utils.getVectorLayerByName(unicode(self.inShape.currentText())) if inLayer.selectedFeatureCount() == 0: QMessageBox.information(self, self.tr("Eliminate"), self.tr("No selection in input layer")) else: self.progressBar.setValue(5) boundary = self.boundary.isChecked() self.eliminate(inLayer, boundary, self.progressBar, outFileName) self.progressBar.setValue(100) self.outShape.clear() self.progressBar.setValue(0) self.buttonOk.setEnabled(True)
def geometry( self, myLayer, myParam, myField ): if self.myFunction == 9: vlayer = ftools_utils.getMapLayerByName( myLayer ) else: vlayer = ftools_utils.getVectorLayerByName( myLayer ) if ( self.myFunction == 5 and self.chkWriteShapefile.isChecked() ) or self.myFunction != 5: check = QFile( self.shapefileName ) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile( self.shapefileName ): QMessageBox.warning( self, self.tr( "Geometry"), self.tr( "Unable to delete existing shapefile." ) ) return if self.myFunction == 5 and not self.chkWriteShapefile.isChecked(): self.shapefileName = None self.encoding = None res = QMessageBox.warning( self, self.tr( "Geometry"), self.tr( "Currently QGIS doesn't allow simultaneous access from " "different threads to the same datasource. Make sure your layer's " "attribute tables are closed. Continue?"), QMessageBox.Yes | QMessageBox.No ) if res == QMessageBox.No: return self.buttonOk.setEnabled( False ) self.testThread = geometryThread( self.iface.mainWindow(), self, self.myFunction, vlayer, myParam, myField, self.shapefileName, self.encoding, self.cmbCalcType.currentIndex(), self.chkWriteShapefile.isChecked(), self.chkByFeatures.isChecked(), self.chkUseSelection.isChecked() ) QObject.connect( self.testThread, SIGNAL( "runFinished( PyQt_PyObject )" ), self.runFinishedFromThread ) QObject.connect( self.testThread, SIGNAL( "runStatus( PyQt_PyObject )" ), self.runStatusFromThread ) QObject.connect( self.testThread, SIGNAL( "runRange( PyQt_PyObject )" ), self.runRangeFromThread ) self.cancel_close.setText( self.tr( "Cancel" ) ) QObject.connect( self.cancel_close, SIGNAL( "clicked()" ), self.cancelThread ) self.testThread.start()
def geometry(self, myLayer, myParam, myField): if self.myFunction == 9: vlayer = ftools_utils.getMapLayerByName(myLayer) else: vlayer = ftools_utils.getVectorLayerByName(myLayer) if (self.myFunction == 5 and self.chkWriteShapefile.isChecked()) or self.myFunction != 5: check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): QMessageBox.warning(self, self.tr("Geometry"), self.tr("Unable to delete existing shapefile.")) return if self.myFunction == 5 and not self.chkWriteShapefile.isChecked(): self.shapefileName = None self.encoding = None res = QMessageBox.warning(self, self.tr("Geometry"), self.tr("Currently QGIS doesn't allow simultaneous access from " "different threads to the same datasource. Make sure your layer's " "attribute tables are closed. Continue?"), QMessageBox.Yes | QMessageBox.No) if res == QMessageBox.No: return self.buttonOk.setEnabled(False) self.testThread = geometryThread(self.iface.mainWindow(), self, self.myFunction, vlayer, myParam, myField, self.shapefileName, self.encoding, self.cmbCalcType.currentIndex(), self.chkWriteShapefile.isChecked(), self.chkByFeatures.isChecked(), self.chkUseSelection.isChecked()) QObject.connect(self.testThread, SIGNAL("runFinished( PyQt_PyObject )"), self.runFinishedFromThread) QObject.connect(self.testThread, SIGNAL("runStatus( PyQt_PyObject )"), self.runStatusFromThread) QObject.connect(self.testThread, SIGNAL("runRange( PyQt_PyObject )"), self.runRangeFromThread) self.cancel_close.setText(self.tr("Cancel")) QObject.connect(self.cancel_close, SIGNAL("clicked()"), self.cancelThread) self.testThread.start()
def compute(self, line1, line2, field1, field2, outPath, progressBar): layer1 = ftools_utils.getVectorLayerByName(line1) provider1 = layer1.dataProvider() fieldList = ftools_utils.getFieldList(layer1) index1 = provider1.fieldNameIndex(field1) field1 = fieldList[index1] field1.setName(unicode(field1.name()) + "_1") layer2 = ftools_utils.getVectorLayerByName(line2) provider2 = layer2.dataProvider() fieldList = ftools_utils.getFieldList(layer2) index2 = provider2.fieldNameIndex(field2) field2 = fieldList[index2] field2.setName(unicode(field2.name()) + "_2") fieldList = QgsFields() fieldList.append(field1) fieldList.append(field2) sRs = provider1.crs() check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, QGis.WKBPoint, sRs) inFeat = QgsFeature() inFeatB = QgsFeature() outFeat = QgsFeature() outFields = QgsFields() outFields.append(field1) outFields.append(field2) outFeat.setFields(outFields) start = 15.00 add = 85.00 / layer1.featureCount() index = ftools_utils.createIndex(provider2) singlelayer_tempList = [] fit1 = provider1.getFeatures(QgsFeatureRequest().setSubsetOfAttributes([index1])) while fit1.nextFeature(inFeat): inGeom = inFeat.geometry() v1 = inFeat.attributes()[index1] lineList = index.intersects(inGeom.boundingBox()) for i in lineList: provider2.getFeatures(QgsFeatureRequest().setFilterFid(int(i)).setSubsetOfAttributes([index2])).nextFeature(inFeatB) tmpGeom = QgsGeometry(inFeatB.geometry()) v2 = inFeatB.attributes()[index2] if inGeom.intersects(tmpGeom): tempGeom = inGeom.intersection(tmpGeom) if tempGeom.type() == QGis.Point: tempList = [] if tempGeom.isMultipart(): tempList = tempGeom.asMultiPoint() else: tempList.append(tempGeom.asPoint()) for j in tempList: # if same layer, avoid insert duplicated points if line1 == line2: if j not in singlelayer_tempList: singlelayer_tempList.append(j) outFeat.setGeometry(tempGeom.fromPoint(j)) outFeat.setAttribute(0, v1) outFeat.setAttribute(1, v2) writer.addFeature(outFeat) else: outFeat.setGeometry(tempGeom.fromPoint(j)) outFeat.setAttribute(0, v1) outFeat.setAttribute(1, v2) writer.addFeature(outFeat) start = start + add progressBar.setValue(start) del writer
def compute(self, inName, weightField="", times=1, uniqueField=""): vlayer = ftools_utils.getVectorLayerByName(inName) provider = vlayer.dataProvider() weightIndex = provider.fieldNameIndex(weightField) uniqueIndex = provider.fieldNameIndex(uniqueField) feat = QgsFeature() sRs = provider.crs() check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return if uniqueIndex != -1: uniqueValues = ftools_utils.getUniqueValues(provider, int( uniqueIndex ) ) single = False else: uniqueValues = [1] single = True if self.function == 2: fieldList = QgsFields() fieldList.append( QgsField("STD_DIST", QVariant.Double) ) fieldList.append( QgsField("UID", QVariant.String) ) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, QGis.WKBPolygon, sRs) else: fieldList = QgsFields() fieldList.append( QgsField("MEAN_X", QVariant.Double) ) fieldList.append( QgsField("MEAN_Y", QVariant.Double) ) fieldList.append( QgsField("UID", QVariant.String) ) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, QGis.WKBPoint, sRs) outfeat = QgsFeature() outfeat.setFields( fieldList ) points = [] weights = [] nFeat = provider.featureCount() * len(uniqueValues) nElement = 0 self.progressBar.setValue(0) self.progressBar.setRange(0, nFeat) for j in uniqueValues: cx = 0.00 cy = 0.00 points = [] weights = [] fit = provider.getFeatures() while fit.nextFeature(feat): nElement += 1 self.progressBar.setValue(nElement) if single: check = unicode(j).strip() else: check = unicode(feat[uniqueIndex]).strip() if check == unicode(j).strip(): cx = 0.00 cy = 0.00 if weightIndex == -1: weight = 1.00 else: weight = float(feat[weightIndex]) geom = QgsGeometry(feat.geometry()) geom = ftools_utils.extractPoints(geom) for i in geom: cx += i.x() cy += i.y() points.append(QgsPoint((cx / len(geom)), (cy / len(geom)))) weights.append(weight) sumWeight = sum(weights) cx = 0.00 cy = 0.00 item = 0 for item, i in enumerate(points): cx += i.x() * weights[item] cy += i.y() * weights[item] cx = cx / sumWeight cy = cy / sumWeight meanPoint = QgsPoint(cx, cy) if self.function == 2: values = [] md = 0.00 sd = 0.00 dist = QgsDistanceArea() item = 0 for i in points: tempDist = dist.measureLine(i, meanPoint) values.append(tempDist) item += 1 md += tempDist md = md / item for i in values: sd += (i-md)*(i-md) sd = sqrt(sd/item) outfeat.setGeometry(QgsGeometry.fromPoint(meanPoint).buffer(sd * times, 10)) outfeat.setAttribute(0, sd) outfeat.setAttribute(1, j) else: outfeat.setGeometry(QgsGeometry.fromPoint(meanPoint)) outfeat.setAttribute(0, cx) outfeat.setAttribute(1, cy) outfeat.setAttribute(2, j) writer.addFeature(outfeat) if single: break del writer
def compute(self, bound, xOffset, yOffset, polygon): crs = None layer = ftools_utils.getMapLayerByName(unicode(self.inShape.currentText())) if self.angle.value() != 0.0: bound = self.initRotation(bound) if layer is None: crs = self.iface.mapCanvas().mapRenderer().destinationCrs() else: crs = layer.crs() if not crs.isValid(): crs = None fields = QgsFields() fields.append(QgsField("ID", QVariant.Int)) fieldCount = 1 if polygon: fields.append(QgsField("X_MIN", QVariant.Double)) fields.append(QgsField("X_MAX", QVariant.Double)) fields.append(QgsField("Y_MIN", QVariant.Double)) fields.append(QgsField("Y_MAX", QVariant.Double)) fieldCount = 5 check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPolygon, crs) else: fields.append(QgsField("COORD", QVariant.Double)) fieldCount = 2 check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBLineString, crs) outFeat = QgsFeature() outFeat.initAttributes(fieldCount) outFeat.setFields(fields) outGeom = QgsGeometry() idVar = 0 self.progressBar.setValue(0) if not polygon: # counters for progressbar - update every 5% count = 0 count_max = (bound.yMaximum() - bound.yMinimum()) / yOffset count_update = count_max * 0.10 y = bound.yMaximum() while y >= bound.yMinimum(): pt1 = QgsPoint(bound.xMinimum(), y) pt2 = QgsPoint(bound.xMaximum(), y) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) line = [pt1, pt2] outFeat.setGeometry(outGeom.fromPolyline(line)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, y) writer.addFeature(outFeat) y = y - yOffset idVar = idVar + 1 count += 1 if int(math.fmod(count, count_update)) == 0: prog = int(count / count_max * 50) self.progressBar.setValue(prog) self.progressBar.setValue(50) # counters for progressbar - update every 5% count = 0 count_max = (bound.xMaximum() - bound.xMinimum()) / xOffset count_update = count_max * 0.10 x = bound.xMinimum() while x <= bound.xMaximum(): pt1 = QgsPoint(x, bound.yMaximum()) pt2 = QgsPoint(x, bound.yMinimum()) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) line = [pt1, pt2] outFeat.setGeometry(outGeom.fromPolyline(line)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, x) writer.addFeature(outFeat) x = x + xOffset idVar = idVar + 1 count += 1 if int(math.fmod(count, count_update)) == 0: prog = 50 + int(count / count_max * 50) self.progressBar.setValue(prog) else: # counters for progressbar - update every 5% count = 0 count_max = (bound.yMaximum() - bound.yMinimum()) / yOffset count_update = count_max * 0.05 y = bound.yMaximum() while y >= bound.yMinimum(): x = bound.xMinimum() while x <= bound.xMaximum(): pt1 = QgsPoint(x, y) pt2 = QgsPoint(x + xOffset, y) pt3 = QgsPoint(x + xOffset, y - yOffset) pt4 = QgsPoint(x, y - yOffset) pt5 = QgsPoint(x, y) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) self.rotatePoint(pt3) self.rotatePoint(pt4) self.rotatePoint(pt5) polygon = [[pt1, pt2, pt3, pt4, pt5]] outFeat.setGeometry(outGeom.fromPolygon(polygon)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, x) outFeat.setAttribute(2, x + xOffset) outFeat.setAttribute(3, y - yOffset) outFeat.setAttribute(4, y) writer.addFeature(outFeat) idVar = idVar + 1 x = x + xOffset y = y - yOffset count += 1 if int(math.fmod(count, count_update)) == 0: prog = int(count / count_max * 100) self.progressBar.setValue(100) del writer
def compute(self, bound, xOffset, yOffset, polygon): crs = None layer = ftools_utils.getMapLayerByName( unicode(self.inShape.currentText())) if self.angle.value() != 0.0: bound = self.initRotation(bound) if layer is None: crs = self.iface.mapCanvas().mapRenderer().destinationCrs() else: crs = layer.crs() if not crs.isValid(): crs = None fields = QgsFields() fields.append(QgsField("ID", QVariant.Int)) fieldCount = 1 if polygon: fields.append(QgsField("X_MIN", QVariant.Double)) fields.append(QgsField("X_MAX", QVariant.Double)) fields.append(QgsField("Y_MIN", QVariant.Double)) fields.append(QgsField("Y_MAX", QVariant.Double)) fieldCount = 5 check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBPolygon, crs) else: fields.append(QgsField("COORD", QVariant.Double)) fieldCount = 2 check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, QGis.WKBLineString, crs) outFeat = QgsFeature() outFeat.initAttributes(fieldCount) outFeat.setFields(fields) outGeom = QgsGeometry() idVar = 0 self.progressBar.setValue(0) if not polygon: # counters for progressbar - update every 5% count = 0 count_max = (bound.yMaximum() - bound.yMinimum()) / yOffset count_update = count_max * 0.10 y = bound.yMaximum() while y >= bound.yMinimum(): pt1 = QgsPoint(bound.xMinimum(), y) pt2 = QgsPoint(bound.xMaximum(), y) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) line = [pt1, pt2] outFeat.setGeometry(outGeom.fromPolyline(line)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, y) writer.addFeature(outFeat) y = y - yOffset idVar = idVar + 1 count += 1 if int(math.fmod(count, count_update)) == 0: prog = int(count / count_max * 50) self.progressBar.setValue(prog) self.progressBar.setValue(50) # counters for progressbar - update every 5% count = 0 count_max = (bound.xMaximum() - bound.xMinimum()) / xOffset count_update = count_max * 0.10 x = bound.xMinimum() while x <= bound.xMaximum(): pt1 = QgsPoint(x, bound.yMaximum()) pt2 = QgsPoint(x, bound.yMinimum()) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) line = [pt1, pt2] outFeat.setGeometry(outGeom.fromPolyline(line)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, x) writer.addFeature(outFeat) x = x + xOffset idVar = idVar + 1 count += 1 if int(math.fmod(count, count_update)) == 0: prog = 50 + int(count / count_max * 50) self.progressBar.setValue(prog) else: # counters for progressbar - update every 5% count = 0 count_max = (bound.yMaximum() - bound.yMinimum()) / yOffset count_update = count_max * 0.05 y = bound.yMaximum() while y >= bound.yMinimum(): x = bound.xMinimum() while x <= bound.xMaximum(): pt1 = QgsPoint(x, y) pt2 = QgsPoint(x + xOffset, y) pt3 = QgsPoint(x + xOffset, y - yOffset) pt4 = QgsPoint(x, y - yOffset) pt5 = QgsPoint(x, y) if self.angle.value() != 0.0: self.rotatePoint(pt1) self.rotatePoint(pt2) self.rotatePoint(pt3) self.rotatePoint(pt4) self.rotatePoint(pt5) polygon = [[pt1, pt2, pt3, pt4, pt5]] outFeat.setGeometry(outGeom.fromPolygon(polygon)) outFeat.setAttribute(0, idVar) outFeat.setAttribute(1, x) outFeat.setAttribute(2, x + xOffset) outFeat.setAttribute(3, y - yOffset) outFeat.setAttribute(4, y) writer.addFeature(outFeat) idVar = idVar + 1 x = x + xOffset y = y - yOffset count += 1 if int(math.fmod(count, count_update)) == 0: prog = int(count / count_max * 100) self.progressBar.setValue(100) del writer
def compute(self, inName, weightField="", times=1, uniqueField=""): vlayer = ftools_utils.getVectorLayerByName(inName) provider = vlayer.dataProvider() weightIndex = provider.fieldNameIndex(weightField) uniqueIndex = provider.fieldNameIndex(uniqueField) feat = QgsFeature() sRs = provider.crs() check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return if uniqueIndex != -1: uniqueValues = ftools_utils.getUniqueValues(provider, int(uniqueIndex)) single = False else: uniqueValues = [1] single = True if self.function == 2: fieldList = QgsFields() fieldList.append(QgsField("STD_DIST", QVariant.Double)) fieldList.append(QgsField("UID", QVariant.String)) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, QGis.WKBPolygon, sRs) else: fieldList = QgsFields() fieldList.append(QgsField("MEAN_X", QVariant.Double)) fieldList.append(QgsField("MEAN_Y", QVariant.Double)) fieldList.append(QgsField("UID", QVariant.String)) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, QGis.WKBPoint, sRs) outfeat = QgsFeature() outfeat.setFields(fieldList) points = [] weights = [] nFeat = provider.featureCount() * len(uniqueValues) nElement = 0 self.progressBar.setValue(0) self.progressBar.setRange(0, nFeat) for j in uniqueValues: cx = 0.00 cy = 0.00 points = [] weights = [] fit = provider.getFeatures() while fit.nextFeature(feat): nElement += 1 self.progressBar.setValue(nElement) if single: check = unicode(j).strip() else: check = unicode(feat[uniqueIndex]).strip() if check == unicode(j).strip(): cx = 0.00 cy = 0.00 if weightIndex == -1: weight = 1.00 else: weight = float(feat[weightIndex]) geom = QgsGeometry(feat.geometry()) geom = ftools_utils.extractPoints(geom) for i in geom: cx += i.x() cy += i.y() points.append(QgsPoint((cx / len(geom)), (cy / len(geom)))) weights.append(weight) sumWeight = sum(weights) cx = 0.00 cy = 0.00 item = 0 for item, i in enumerate(points): cx += i.x() * weights[item] cy += i.y() * weights[item] cx = cx / sumWeight cy = cy / sumWeight meanPoint = QgsPoint(cx, cy) if self.function == 2: values = [] md = 0.00 sd = 0.00 dist = QgsDistanceArea() item = 0 for i in points: tempDist = dist.measureLine(i, meanPoint) values.append(tempDist) item += 1 md += tempDist md = md / item for i in values: sd += (i - md) * (i - md) sd = sqrt(sd / item) outfeat.setGeometry(QgsGeometry.fromPoint(meanPoint).buffer(sd * times, 10)) outfeat.setAttribute(0, sd) outfeat.setAttribute(1, j) else: outfeat.setGeometry(QgsGeometry.fromPoint(meanPoint)) outfeat.setAttribute(0, cx) outfeat.setAttribute(1, cy) outfeat.setAttribute(2, j) writer.addFeature(outfeat) if single: break del writer
def run(self): self.mutex.lock() self.stopMe = 0 self.mutex.unlock() interrupted = False polyProvider = self.layerPoly.dataProvider() pointProvider = self.layerPoints.dataProvider() fieldList = ftools_utils.getFieldList(self.layerPoly) index = polyProvider.fieldNameIndex(unicode(self.fieldName)) if index == -1: index = polyProvider.fields().count() fieldList.append( QgsField(unicode(self.fieldName), QVariant.Int, "int", 10, 0, self.tr("point count field"))) # Add the selected vector fields to the output polygon vector layer selectedItems = self.attributeList.selectedItems() for item in selectedItems: global typeDouble columnName = unicode(item.text() + "_" + self.statistics) index = polyProvider.fieldNameIndex(unicode(columnName)) if index == -1: if item.type( ) == typeDouble or self.statistics == "mean" or self.statistics == "stddev": fieldList.append( QgsField(columnName, QVariant.Double, "double", 24, 15, "Value")) else: fieldList.append( QgsField(columnName, QVariant.Int, "int", 10, 0, "Value")) sRs = polyProvider.crs() if QFile(self.outPath).exists(): if not QgsVectorFileWriter.deleteShapeFile(self.outPath): return writer = QgsVectorFileWriter(self.outPath, self.encoding, fieldList, polyProvider.geometryType(), sRs) spatialIndex = ftools_utils.createIndex(pointProvider) self.emit(SIGNAL("rangeChanged(int)"), polyProvider.featureCount()) polyFeat = QgsFeature() pntFeat = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() polyFit = polyProvider.getFeatures() while polyFit.nextFeature(polyFeat): inGeom = polyFeat.geometry() atMap = polyFeat.attributes() outFeat.setAttributes(atMap) outFeat.setGeometry(inGeom) count = 0 pointList = [] hasIntersection = True pointList = spatialIndex.intersects(inGeom.boundingBox()) if len(pointList) > 0: hasIntersection = True else: hasIntersection = False if hasIntersection: valueList = {} for item in selectedItems: valueList[item.text()] = [] for p in pointList: pointProvider.getFeatures(QgsFeatureRequest().setFilterFid( p)).nextFeature(pntFeat) tmpGeom = QgsGeometry(pntFeat.geometry()) if inGeom.intersects(tmpGeom): count += 1 for item in selectedItems: valueList[item.text()].append( pntFeat.attribute(item.text())) self.mutex.lock() s = self.stopMe self.mutex.unlock() if s == 1: interrupted = True break atMap.append(count) # Compute the statistical values for selected vector attributes for item in selectedItems: values = valueList[item.text()] # Check if the input contains non-numeric values non_numeric_values = False for value in values: if not isinstance(value, type( float())) and not isinstance( value, type(int())): non_numeric_values = True break # Jump over invalid values if non_numeric_values is True: continue if values and len(values) > 0: if self.statistics == "sum": value = reduce(myAdder, values) elif self.statistics == "mean": value = reduce(myAdder, values) / float( len(values)) elif self.statistics == "min": values.sort() value = values[0] elif self.statistics == "max": values.sort() value = values[-1] elif self.statistics == "stddev": value = two_pass_variance(values) value = math.sqrt(value) atMap.append(value) outFeat.setAttributes(atMap) writer.addFeature(outFeat) self.emit(SIGNAL("updateProgress()")) self.mutex.lock() s = self.stopMe self.mutex.unlock() if s == 1: interrupted = True break del writer if not interrupted: self.emit(SIGNAL("processingFinished()")) else: self.emit(SIGNAL("processingInterrupted()"))
def run(self): self.mutex.lock() self.stopMe = 0 self.mutex.unlock() interrupted = False polyProvider = self.layerPoly.dataProvider() pointProvider = self.layerPoints.dataProvider() fieldList = ftools_utils.getFieldList(self.layerPoly) index = polyProvider.fieldNameIndex(unicode(self.fieldName)) if index == -1: index = polyProvider.fields().count() fieldList.append( QgsField(unicode(self.fieldName), QVariant.Int, "int", 10, 0, self.tr("point count field")) ) sRs = polyProvider.crs() if QFile(self.outPath).exists(): if not QgsVectorFileWriter.deleteShapeFile(self.outPath): return writer = QgsVectorFileWriter(self.outPath, self.encoding, fieldList, polyProvider.geometryType(), sRs) spatialIndex = ftools_utils.createIndex( pointProvider ) self.emit(SIGNAL("rangeChanged(int)"), polyProvider.featureCount() ) polyFeat = QgsFeature() pntFeat = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() polyFit = polyProvider.getFeatures() while polyFit.nextFeature(polyFeat): inGeom = polyFeat.geometry() atMap = polyFeat.attributes() outFeat.setAttributes(atMap) outFeat.setGeometry(inGeom) count = 0 pointList = [] hasIntersection = True pointList = spatialIndex.intersects(inGeom.boundingBox()) if len(pointList) > 0: hasIntersection = True else: hasIntersection = False if hasIntersection: for p in pointList: pointProvider.getFeatures( QgsFeatureRequest().setFilterFid( p ) ).nextFeature( pntFeat ) tmpGeom = QgsGeometry(pntFeat.geometry()) if inGeom.intersects(tmpGeom): count += 1 self.mutex.lock() s = self.stopMe self.mutex.unlock() if s == 1: interrupted = True break atMap.append(count) outFeat.setAttributes(atMap) writer.addFeature(outFeat) self.emit( SIGNAL( "updateProgress()" ) ) self.mutex.lock() s = self.stopMe self.mutex.unlock() if s == 1: interrupted = True break del writer if not interrupted: self.emit( SIGNAL( "processingFinished()" ) ) else: self.emit( SIGNAL( "processingInterrupted()" ) )
def delete_shp(path): QgsVectorFileWriter.deleteShapeFile(path) path = os.path.splitext(path)[0] + ".cpg" if os.path.exists(path): os.remove(path)
def run(self): self.mutex.lock() self.stopMe = 0 self.mutex.unlock() interrupted = False polyProvider = self.layerPoly.dataProvider() pointProvider = self.layerPoints.dataProvider() fieldList = ftools_utils.getFieldList(self.layerPoly) index = polyProvider.fieldNameIndex(unicode(self.fieldName)) if index == -1: index = polyProvider.fields().count() fieldList.append( QgsField(unicode(self.fieldName), QVariant.Int, "int", 10, 0, self.tr("point count field")) ) # Add the selected vector fields to the output polygon vector layer selectedItems = self.attributeList.selectedItems() for item in selectedItems: global typeDouble columnName = unicode(item.text() + "_" + self.statistics) index = polyProvider.fieldNameIndex(unicode(columnName)) if index == -1: if item.type() == typeDouble or self.statistics == "mean" or self.statistics == "stddev": fieldList.append( QgsField(columnName, QVariant.Double, "double", 24, 15, "Value") ) else: fieldList.append( QgsField(columnName, QVariant.Int, "int", 10, 0, "Value") ) sRs = polyProvider.crs() if QFile(self.outPath).exists(): if not QgsVectorFileWriter.deleteShapeFile(self.outPath): return writer = QgsVectorFileWriter(self.outPath, self.encoding, fieldList, polyProvider.geometryType(), sRs) spatialIndex = ftools_utils.createIndex( pointProvider ) self.emit(SIGNAL("rangeChanged(int)"), polyProvider.featureCount() ) polyFeat = QgsFeature() pntFeat = QgsFeature() outFeat = QgsFeature() inGeom = QgsGeometry() polyFit = polyProvider.getFeatures() while polyFit.nextFeature(polyFeat): inGeom = polyFeat.geometry() atMap = polyFeat.attributes() outFeat.setAttributes(atMap) outFeat.setGeometry(inGeom) count = 0 pointList = [] hasIntersection = True pointList = spatialIndex.intersects(inGeom.boundingBox()) if len(pointList) > 0: hasIntersection = True else: hasIntersection = False if hasIntersection: valueList = {} for item in selectedItems: valueList[item.text()] = [] for p in pointList: pointProvider.getFeatures( QgsFeatureRequest().setFilterFid( p ) ).nextFeature( pntFeat ) tmpGeom = QgsGeometry(pntFeat.geometry()) if inGeom.intersects(tmpGeom): count += 1 for item in selectedItems: valueList[item.text()].append(pntFeat.attribute(item.text())) self.mutex.lock() s = self.stopMe self.mutex.unlock() if s == 1: interrupted = True break atMap.append(count) # Compute the statistical values for selected vector attributes for item in selectedItems: values = valueList[item.text()] # Check if the input contains non-numeric values non_numeric_values = False for value in values: if not isinstance(value, type(float())) and not isinstance(value, type(int())): non_numeric_values = True break # Jump over invalid values if non_numeric_values is True: continue if values and len(values) > 0: if self.statistics == "sum": value = reduce(myAdder, values) elif self.statistics == "mean": value = reduce(myAdder, values) / float(len(values)) elif self.statistics == "min": values.sort() value = values[0] elif self.statistics == "max": values.sort() value = values[-1] elif self.statistics == "stddev": value = two_pass_variance(values) value = math.sqrt(value) atMap.append(value) outFeat.setAttributes(atMap) writer.addFeature(outFeat) self.emit( SIGNAL( "updateProgress()" ) ) self.mutex.lock() s = self.stopMe self.mutex.unlock() if s == 1: interrupted = True break del writer if not interrupted: self.emit( SIGNAL( "processingFinished()" ) ) else: self.emit( SIGNAL( "processingInterrupted()" ) )
def abort(): for writer in physicalWriter.values(): QgsVectorFileWriter.deleteShapeFile(writer.path + ".shp") QFile.remove(writer.path + ".cpg")
def compute(self, inName, joinName, outName, summary, sumList, keep, progressBar): layer1 = ftools_utils.getVectorLayerByName(inName) provider1 = layer1.dataProvider() fieldList1 = ftools_utils.getFieldList(layer1) layer2 = ftools_utils.getVectorLayerByName(joinName) provider2 = layer2.dataProvider() fieldList2 = ftools_utils.getFieldList(layer2) fieldList = QgsFields() if provider1.crs() != provider2.crs(): QMessageBox.warning( self, self.tr("CRS warning!"), self. tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results." )) if not summary: fieldList2 = ftools_utils.testForUniqueness(fieldList1, fieldList2) seq = range(0, len(fieldList1) + len(fieldList2)) fieldList1.extend(fieldList2) fieldList1 = dict(zip(seq, fieldList1)) else: numFields = {} for j in xrange(len(fieldList2)): if fieldList2[j].type() == QVariant.Int or fieldList2[j].type( ) == QVariant.Double: numFields[j] = [] for i in sumList: field = QgsField(i + unicode(fieldList2[j].name()), QVariant.Double, "real", 24, 16, self.tr("Summary field")) fieldList.append(field) field = QgsField("COUNT", QVariant.Double, "real", 24, 16, self.tr("Summary field")) fieldList.append(field) fieldList2 = ftools_utils.testForUniqueness(fieldList1, fieldList) fieldList1.extend(fieldList) seq = range(0, len(fieldList1)) fieldList1 = dict(zip(seq, fieldList1)) sRs = provider1.crs() progressBar.setValue(13) check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): QMessageBox.warning( self, self.tr('Error deleting shapefile'), self.tr("Can't delete existing shapefile\n%s") % (self.shapefileName)) return False fields = QgsFields() for f in fieldList1.values(): fields.append(f) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, provider1.geometryType(), sRs) #writer = QgsVectorFileWriter(outName, "UTF-8", fieldList1, provider1.geometryType(), sRs) inFeat = QgsFeature() outFeat = QgsFeature() inFeatB = QgsFeature() inGeom = QgsGeometry() progressBar.setValue(15) start = 15.00 add = 85.00 / provider1.featureCount() index = ftools_utils.createIndex(provider2) # cache all features from provider2 to avoid huge number of feature requests in the inner loop mapP2 = {} for f in provider2.getFeatures(): mapP2[f.id()] = QgsFeature(f) fit1 = provider1.getFeatures() while fit1.nextFeature(inFeat): inGeom = inFeat.geometry() atMap1 = inFeat.attributes() outFeat.setGeometry(inGeom) none = True joinList = [] if inGeom.type() == QGis.Point: #(check, joinList) = layer2.featuresInRectangle(inGeom.buffer(10,2).boundingBox(), True, True) #layer2.select(inGeom.buffer(10,2).boundingBox(), False) #joinList = layer2.selectedFeatures() joinList = index.intersects(inGeom.buffer(10, 2).boundingBox()) if len(joinList) > 0: check = 0 else: check = 1 else: #(check, joinList) = layer2.featuresInRectangle(inGeom.boundingBox(), True, True) #layer2.select(inGeom.boundingBox(), False) #joinList = layer2.selectedFeatures() joinList = index.intersects(inGeom.boundingBox()) if len(joinList) > 0: check = 0 else: check = 1 if check == 0: count = 0 for i in joinList: inFeatB = mapP2[i] # cached feature from provider2 if inGeom.intersects(inFeatB.geometry()): count = count + 1 none = False atMap2 = inFeatB.attributes() if not summary: atMap = atMap1 atMap2 = atMap2 atMap.extend(atMap2) atMap = dict(zip(seq, atMap)) break else: for j in numFields.keys(): numFields[j].append(atMap2[j]) if summary and not none: atMap = atMap1 for j in numFields.keys(): for k in sumList: if k == "SUM": atMap.append(sum(filter_null(numFields[j]))) elif k == "MEAN": try: nn_count = sum( 1 for _ in filter_null(numFields[j])) atMap.append( sum(filter_null(numFields[j])) / nn_count) except ZeroDivisionError: atMap.append(NULL) elif k == "MIN": try: atMap.append(min(filter_null( numFields[j]))) except ValueError: atMap.append(NULL) elif k == "MED": atMap.append(myself(numFields[j])) else: try: atMap.append(max(filter_null( numFields[j]))) except ValueError: atMap.append(NULL) numFields[j] = [] atMap.append(count) atMap = dict(zip(seq, atMap)) if none: outFeat.setAttributes(atMap1) else: outFeat.setAttributes(atMap.values()) if keep: # keep all records writer.addFeature(outFeat) else: # keep only matching records if not none: writer.addFeature(outFeat) start = start + add progressBar.setValue(start) del writer return True
def compute(self, inName, joinName, outName, summary, sumList, keep, progressBar): layer1 = ftools_utils.getVectorLayerByName(inName) provider1 = layer1.dataProvider() fieldList1 = ftools_utils.getFieldList(layer1) layer2 = ftools_utils.getVectorLayerByName(joinName) provider2 = layer2.dataProvider() fieldList2 = ftools_utils.getFieldList(layer2) fieldList = QgsFields() if provider1.crs() != provider2.crs(): QMessageBox.warning(self, self.tr("CRS warning!"), self.tr("Warning: Input layers have non-matching CRS.\nThis may cause unexpected results.")) if not summary: fieldList2 = ftools_utils.testForUniqueness(fieldList1, fieldList2) seq = range(0, len(fieldList1) + len(fieldList2)) fieldList1.extend(fieldList2) fieldList1 = dict(zip(seq, fieldList1)) else: numFields = {} for j in xrange(len(fieldList2)): if fieldList2[j].type() == QVariant.Int or fieldList2[j].type() == QVariant.Double: numFields[j] = [] for i in sumList: field = QgsField(i + unicode(fieldList2[j].name()), QVariant.Double, "real", 24, 16, self.tr("Summary field")) fieldList.append(field) field = QgsField("COUNT", QVariant.Double, "real", 24, 16, self.tr("Summary field")) fieldList.append(field) fieldList2 = ftools_utils.testForUniqueness(fieldList1, fieldList) fieldList1.extend(fieldList) seq = range(0, len(fieldList1)) fieldList1 = dict(zip(seq, fieldList1)) sRs = provider1.crs() progressBar.setValue(13) check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): QMessageBox.warning( self, self.tr('Error deleting shapefile'), self.tr("Can't delete existing shapefile\n%s") % (self.shapefileName)) return False fields = QgsFields() for f in fieldList1.values(): fields.append(f) writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fields, provider1.geometryType(), sRs) #writer = QgsVectorFileWriter(outName, "UTF-8", fieldList1, provider1.geometryType(), sRs) inFeat = QgsFeature() outFeat = QgsFeature() inFeatB = QgsFeature() inGeom = QgsGeometry() progressBar.setValue(15) start = 15.00 add = 85.00 / provider1.featureCount() index = ftools_utils.createIndex(provider2) # cache all features from provider2 to avoid huge number of feature requests in the inner loop mapP2 = {} for f in provider2.getFeatures(): mapP2[f.id()] = QgsFeature(f) fit1 = provider1.getFeatures() while fit1.nextFeature(inFeat): inGeom = inFeat.geometry() atMap1 = inFeat.attributes() outFeat.setGeometry(inGeom) none = True joinList = [] if inGeom.type() == QGis.Point: #(check, joinList) = layer2.featuresInRectangle(inGeom.buffer(10,2).boundingBox(), True, True) #layer2.select(inGeom.buffer(10,2).boundingBox(), False) #joinList = layer2.selectedFeatures() joinList = index.intersects(inGeom.buffer(10, 2).boundingBox()) if len(joinList) > 0: check = 0 else: check = 1 else: #(check, joinList) = layer2.featuresInRectangle(inGeom.boundingBox(), True, True) #layer2.select(inGeom.boundingBox(), False) #joinList = layer2.selectedFeatures() joinList = index.intersects(inGeom.boundingBox()) if len(joinList) > 0: check = 0 else: check = 1 if check == 0: count = 0 for i in joinList: inFeatB = mapP2[i] # cached feature from provider2 if inGeom.intersects(inFeatB.geometry()): count = count + 1 none = False atMap2 = inFeatB.attributes() if not summary: atMap = atMap1 atMap2 = atMap2 atMap.extend(atMap2) atMap = dict(zip(seq, atMap)) break else: for j in numFields.keys(): numFields[j].append(atMap2[j]) if summary and not none: atMap = atMap1 for j in numFields.keys(): for k in sumList: if k == "SUM": atMap.append(sum(filter_null(numFields[j]))) elif k == "MEAN": try: nn_count = sum(1 for _ in filter_null(numFields[j])) atMap.append(sum(filter_null(numFields[j])) / nn_count) except ZeroDivisionError: atMap.append(NULL) elif k == "MIN": try: atMap.append(min(filter_null(numFields[j]))) except ValueError: atMap.append(NULL) elif k == "MED": atMap.append(myself(numFields[j])) else: try: atMap.append(max(filter_null(numFields[j]))) except ValueError: atMap.append(NULL) numFields[j] = [] atMap.append(count) atMap = dict(zip(seq, atMap)) if none: outFeat.setAttributes(atMap1) else: outFeat.setAttributes(atMap.values()) if keep: # keep all records writer.addFeature(outFeat) else: # keep only matching records if not none: writer.addFeature(outFeat) start = start + add progressBar.setValue(start) del writer return True
def compute(self, line1, line2, field1, field2, outPath, progressBar): layer1 = ftools_utils.getVectorLayerByName(line1) provider1 = layer1.dataProvider() fieldList = ftools_utils.getFieldList(layer1) index1 = provider1.fieldNameIndex(field1) field1 = fieldList[index1] field1.setName(unicode(field1.name()) + "_1") layer2 = ftools_utils.getVectorLayerByName(line2) provider2 = layer2.dataProvider() fieldList = ftools_utils.getFieldList(layer2) index2 = provider2.fieldNameIndex(field2) field2 = fieldList[index2] field2.setName(unicode(field2.name()) + "_2") fieldList = QgsFields() fieldList.append(field1) fieldList.append(field2) sRs = provider1.crs() check = QFile(self.shapefileName) if check.exists(): if not QgsVectorFileWriter.deleteShapeFile(self.shapefileName): return writer = QgsVectorFileWriter(self.shapefileName, self.encoding, fieldList, QGis.WKBPoint, sRs) inFeat = QgsFeature() inFeatB = QgsFeature() outFeat = QgsFeature() outFields = QgsFields() outFields.append(field1) outFields.append(field2) outFeat.setFields(outFields) start = 15.00 add = 85.00 / layer1.featureCount() index = ftools_utils.createIndex(provider2) singlelayer_tempList = [] fit1 = provider1.getFeatures(QgsFeatureRequest().setSubsetOfAttributes( [index1])) while fit1.nextFeature(inFeat): inGeom = inFeat.geometry() v1 = inFeat.attributes()[index1] lineList = index.intersects(inGeom.boundingBox()) for i in lineList: provider2.getFeatures(QgsFeatureRequest().setFilterFid( int(i)).setSubsetOfAttributes([index2 ])).nextFeature(inFeatB) tmpGeom = QgsGeometry(inFeatB.geometry()) v2 = inFeatB.attributes()[index2] if inGeom.intersects(tmpGeom): tempGeom = inGeom.intersection(tmpGeom) if tempGeom.type() == QGis.Point: tempList = [] if tempGeom.isMultipart(): tempList = tempGeom.asMultiPoint() else: tempList.append(tempGeom.asPoint()) for j in tempList: # if same layer, avoid insert duplicated points if line1 == line2: if j not in singlelayer_tempList: singlelayer_tempList.append(j) outFeat.setGeometry(tempGeom.fromPoint(j)) outFeat.setAttribute(0, v1) outFeat.setAttribute(1, v2) writer.addFeature(outFeat) else: outFeat.setGeometry(tempGeom.fromPoint(j)) outFeat.setAttribute(0, v1) outFeat.setAttribute(1, v2) writer.addFeature(outFeat) start = start + add progressBar.setValue(start) del writer
def on_btnRun_clicked(self): if self.inputfile == '': QMessageBox.critical(self,'Map Creator', 'Please specify input coordinate file.') return if self.outputfile == '': QMessageBox.critical(self,'Map Creator', 'Please specify output shapefile.') return self.setCursor(Qt.WaitCursor) #Open coordinate input file f = open(self.inputfile, 'r') lines = f.readlines() f.close() header = lines[0].split(',')[0] totfeat = len(lines) - 1 lines.pop(0) lines.reverse() #Create vector layer basename = os.path.basename(self.outputfile) vlayer = QgsVectorLayer("Polygon", basename, "memory") vprovider = vlayer.dataProvider() fld = QgsField(header,QVariant.String) flds = QgsFields() flds.append(fld) vprovider.addAttributes([fld]) vlayer.startEditing() hull = [] for cnt, line in enumerate(lines): line = line.rstrip().split(',') numcoords = int((len(line) - 1) / 2) hull[:] = [] geom = QgsGeometry() feat = QgsFeature() feat.setFields(flds) for i in range(numcoords): hull.append(QgsPointXY(float(line[i*2+1]),float(line[i*2+2]))) geom = geom.fromMultiPointXY(hull) geom = geom.convexHull() feat.setGeometry(geom) feat.setAttribute(header,str(line[0])) result = vlayer.addFeature(feat) if not result: self.setCursor(Qt.ArrowCursor) QMessageBox.critical(self,'Map Creator', 'Processing error.') return self.ui.ProgressBar.setValue(float(cnt+1)/float(totfeat) * 100.0) QApplication.processEvents() vlayer.commitChanges() vlayer.updateExtents() #Write the output shapefile if os.path.exists(self.outputfile): QgsVectorFileWriter.deleteShapeFile(self.outputfile) voptions = QgsVectorFileWriter.SaveVectorOptions() voptions.driverName = 'ESRI Shapefile' voptions.fileEncoding = 'utf-8' result = QgsVectorFileWriter.writeAsVectorFormat(vlayer, self.outputfile, voptions) if result[0] != 0: QMessageBox.critical(self,'Map Creator','Error creating shapefile.') else: #Ask to add shapfile to map name = QFileInfo(self.outputfile).completeBaseName() result = QMessageBox.question(self,'Map Creator', 'Add shapefile to map?', QMessageBox.Yes, QMessageBox.No) if result == QMessageBox.Yes: self.iface.addVectorLayer(self.outputfile, name, 'ogr') self.setCursor(Qt.ArrowCursor)
def on_btnRun_clicked(self): if self.ui.cmbProcessLayer.count() <= 0: return if self.ui.tbxOutput.text() == '': QMessageBox.critical(self, 'Raster to Vector Converter', 'Please specify output shapefile.') return self.setCursor(Qt.WaitCursor) #Get raster properties numX = self.player.width() numY = self.player.height() pixsizeX = self.player.rasterUnitsPerPixelX() pixsizeY = self.player.rasterUnitsPerPixelY() extents = self.player.extent() LLX = extents.xMinimum() LLY = extents.yMinimum() URX = extents.xMaximum() URY = extents.yMaximum() rprovider = self.player.dataProvider() if LLX > URX or LLY > URY: self.setCursor(Qt.ArrowCursor) QMessageBox.critical(self, 'Raster to Vector Converter', 'Unexpected image extents.') return #Create vector layer of pixel polygons or points at pixel centers #Assumes image extents are given as the LL coordinate of LL pixel #and UR coordinate of UR pixel. pfeat = QgsFeature() crsid = str(self.player.crs().authid()) if self.ui.rbPoints.isChecked(): pvlayer = QgsVectorLayer("Point?crs=" + crsid, "templayer", "memory") elif self.ui.rbPolygons.isChecked(): pvlayer = QgsVectorLayer("Polygon?crs=" + crsid, "templayer", "memory") fields = [QgsField("ID", QVariant.Int)] for i in range(self.player.bandCount()): bandname = self.player.bandName(i + 1) fields.append(QgsField(bandname, QVariant.Double)) pprovider = pvlayer.dataProvider() pprovider.addAttributes(fields) pvlayer.startEditing() count = 0 attr = [] totpix = float(numX * numY) for y in range(numY): for x in range(numX): newpt = QgsPoint(LLX + x * pixsizeX + pixsizeX / 2.0, LLY + y * pixsizeY + pixsizeY / 2.0) data = rprovider.identify(newpt, 1).results() if self.ui.rbPoints.isChecked(): pfeat.setGeometry(QgsGeometry.fromPoint(newpt)) elif self.ui.rbPolygons.isChecked(): newrect = QgsRectangle(LLX + x * pixsizeX, LLY + y * pixsizeY, LLX + x * pixsizeX + pixsizeX, LLY + y * pixsizeY + pixsizeY) pfeat.setGeometry(QgsGeometry.fromRect(newrect)) attr = list(data.values()) attr.insert(0, count) pfeat.setAttributes(attr) result = pvlayer.addFeature(pfeat) if not result: self.setCursor(Qt.ArrowCursor) QMessageBox.critical(self, 'Raster to Vector Converter', 'Processing error 2.') return del newpt if self.ui.rbPolygons.isChecked(): del newrect count += 1 self.ui.ProgressBar.setValue(float(count) / totpix * 100.0) QApplication.processEvents() pvlayer.commitChanges() pvlayer.updateExtents() #Write the output shapefile if os.path.exists(self.outfile): QgsVectorFileWriter.deleteShapeFile(self.outfile) result = QgsVectorFileWriter.writeAsVectorFormat( pvlayer, self.outfile, 'utf-8', self.player.crs()) if result != QgsVectorFileWriter.NoError: QMessageBox.critical(self, 'Raster to Vector Converter', 'Error creating shapefile.') else: #Ask to add shapfile to map name = QFileInfo(self.outfile).completeBaseName() result = QMessageBox.question(self, 'Raster to Vector Converter', 'Add shapefile to map?', QMessageBox.Yes, QMessageBox.No) if result == QMessageBox.Yes: self.iface.addVectorLayer(self.outfile, name, 'ogr') self.setCursor(Qt.ArrowCursor) self.close()
def calculate(self): ''' Prepare environment to run the alg and run it. After run, merge produced data basing on plugin configuration. Before calculation a parametere validation will be executed ''' # perform validation if not self.gui.validate(): return else: # notify successful validation message = self.tr("QTraffic: Parameters validation passed successfully") iface.messageBar().pushMessage(message, QgsMessageBar.SUCCESS) # set number of classes in the project config (that is the temporary one... but equal to the official one) fleetDistributionRoadTypes = self.gui.getRoadTypes() self.project.setValue('Processing.Parameters/maximum_type', len(fleetDistributionRoadTypes)) self.project.sync() # create the algorithm self.alg = Algorithm() roadLayer = self.gui.getRoadLayer() # prepare layer where to add result addToInputLayer = self.gui.addToOriginaLayer_RButton.isChecked() newOutputLayer = self.gui.outFile_LEdit.text() if addToInputLayer: self.outLayer = roadLayer self.outLayerId = self.outLayer.id() else: # if layer is present... remove it # out layer would not be the same of input road layer... in thi scase don't remove it if self.outLayer and self.outLayer.isValid(): # to be sure, remove only if roadLayer and outLayer are different if self.outLayer.publicSource() != roadLayer.publicSource(): self.outLayerRemoved = False QgsMapLayerRegistry.instance().layerRemoved.connect(self.checkOutLayerRemoved) QgsMapLayerRegistry.instance().removeMapLayer(self.outLayer.id()) # remove file when it has been removed from qgis while not self.outLayerRemoved: sleep(0.1) QgsMapLayerRegistry.instance().layerRemoved.disconnect(self.checkOutLayerRemoved) # reinit outLayer variables # If not, under windws remain a locking of the related file creating # an error during QgsVectorFileWriter.deleteShapeFile self.outLayer = None self.outLayerId = None if os.path.exists(newOutputLayer): if not QgsVectorFileWriter.deleteShapeFile(newOutputLayer): message = self.tr("Error removing shape: {}".format(newOutputLayer)) iface.messageBar().pushMessage(message, QgsMessageBar.CRITICAL) return # copy input layer to the new one writeError = QgsVectorFileWriter.writeAsVectorFormat(roadLayer, newOutputLayer, 'utf-8', roadLayer.crs()) if writeError != QgsVectorFileWriter.NoError: message = self.tr('Error writing vector file {}'.format(newOutputLayer)) QgsMessageLog.logMessage(message, 'QTraffic', QgsMessageLog.CRITICAL) iface.messageBar().pushCritical('QTraffic', message) return # load the layer newLayerName =os.path.splitext(os.path.basename( newOutputLayer ))[0] self.outLayer = QgsVectorLayer(newOutputLayer, newLayerName, 'ogr') if not self.outLayer.isValid(): message = self.tr('Error loading vector file {}'.format(newOutputLayer)) QgsMessageLog.logMessage(message, 'QTraffic', QgsMessageLog.CRITICAL) iface.messageBar().pushCritical('QTraffic', message) return self.outLayerId = self.outLayer.id() # prepare environment try: self.alg.setProject(self.project) self.alg.setLayer( roadLayer ) self.alg.initConfig() self.alg.prepareRun() except Exception as ex: traceback.print_exc() message = self.tr('Error preparing running contex for the algoritm: %s' % str(ex)) QgsMessageLog.logMessage(message, 'QTraffic', QgsMessageLog.CRITICAL) iface.messageBar().pushCritical('QTraffic', message) return # run the self.alg self.thread = QtCore.QThread(self) self.thread.started.connect(self.alg.run) self.thread.finished.connect(self.threadCleanup) self.thread.terminated.connect(self.threadCleanup) self.alg.moveToThread(self.thread) self.alg.started.connect(self.manageStarted) self.alg.progress.connect(self.manageProgress) self.alg.message.connect(self.manageMessage) self.alg.error.connect(self.manageError) self.alg.finished.connect(self.manageFinished) # set wait cursor and start QgsApplication.instance().setOverrideCursor(QtCore.Qt.WaitCursor) self.thread.start()
'CALC_METHOD':1,\ 'OUTPUT':floodIntersectionWithGeo }) iface.addVectorLayer(riverIntersectionWithGeo, '', 'ogr') iface.addVectorLayer(floodIntersectionWithGeo, '', 'ogr') print("Intersections created.") #------------------------------------------------------------------------------------------------------------------ # deleting extra files print("Delecting Extra file...") for path in exFiles: print("deleting", path, "...") QgsVectorFileWriter.deleteShapeFile(path) print("Extra files deleted.") #------------------------------------------------------------------------------------------------------------------ # Calculating distances print("Calculating distance...") riverLayer = QgsProject.instance().mapLayersByName('RiverIntersectionWithGeo') floodLayer = QgsProject.instance().mapLayersByName('FloodIntersectionWithGeo') #print(lyr) rRightBorder = [] rLeftBorder = []
def calculate(self): ''' Prepare environment to run the alg and run it. After run, merge produced data basing on plugin configuration. Before calculation a parametere validation will be executed ''' # perform validation if not self.gui.validate(): return else: # notify successful validation message = self.tr( "QTraffic: Parameters validation passed successfully") iface.messageBar().pushMessage(message, QgsMessageBar.SUCCESS) # set number of classes in the project config (that is the temporary one... but equal to the official one) fleetDistributionRoadTypes = self.gui.getRoadTypes() self.project.setValue('Processing.Parameters/maximum_type', len(fleetDistributionRoadTypes)) self.project.sync() # create the algorithm self.alg = Algorithm() roadLayer = self.gui.getRoadLayer() # prepare layer where to add result addToInputLayer = self.gui.addToOriginaLayer_RButton.isChecked() newOutputLayer = self.gui.outFile_LEdit.text() if addToInputLayer: self.outLayer = roadLayer self.outLayerId = self.outLayer.id() else: # if layer is present... remove it # out layer would not be the same of input road layer... in thi scase don't remove it if self.outLayer and self.outLayer.isValid(): # to be sure, remove only if roadLayer and outLayer are different if self.outLayer.publicSource() != roadLayer.publicSource(): self.outLayerRemoved = False QgsMapLayerRegistry.instance().layerRemoved.connect( self.checkOutLayerRemoved) QgsMapLayerRegistry.instance().removeMapLayer( self.outLayer.id()) # remove file when it has been removed from qgis while not self.outLayerRemoved: sleep(0.1) QgsMapLayerRegistry.instance().layerRemoved.disconnect( self.checkOutLayerRemoved) # reinit outLayer variables # If not, under windws remain a locking of the related file creating # an error during QgsVectorFileWriter.deleteShapeFile self.outLayer = None self.outLayerId = None if os.path.exists(newOutputLayer): if not QgsVectorFileWriter.deleteShapeFile( newOutputLayer): message = self.tr( "Error removing shape: {}".format( newOutputLayer)) iface.messageBar().pushMessage( message, QgsMessageBar.CRITICAL) return # copy input layer to the new one writeError = QgsVectorFileWriter.writeAsVectorFormat( roadLayer, newOutputLayer, 'utf-8', roadLayer.crs()) if writeError != QgsVectorFileWriter.NoError: message = self.tr( 'Error writing vector file {}'.format(newOutputLayer)) QgsMessageLog.logMessage(message, 'QTraffic', QgsMessageLog.CRITICAL) iface.messageBar().pushCritical('QTraffic', message) return # load the layer newLayerName = os.path.splitext( os.path.basename(newOutputLayer))[0] self.outLayer = QgsVectorLayer(newOutputLayer, newLayerName, 'ogr') if not self.outLayer.isValid(): message = self.tr( 'Error loading vector file {}'.format(newOutputLayer)) QgsMessageLog.logMessage(message, 'QTraffic', QgsMessageLog.CRITICAL) iface.messageBar().pushCritical('QTraffic', message) return self.outLayerId = self.outLayer.id() # prepare environment try: self.alg.setProject(self.project) self.alg.setLayer(roadLayer) self.alg.initConfig() self.alg.prepareRun() except Exception as ex: traceback.print_exc() message = self.tr( 'Error preparing running contex for the algoritm: %s' % str(ex)) QgsMessageLog.logMessage(message, 'QTraffic', QgsMessageLog.CRITICAL) iface.messageBar().pushCritical('QTraffic', message) return # run the self.alg self.thread = QtCore.QThread(self) self.thread.started.connect(self.alg.run) self.thread.finished.connect(self.threadCleanup) self.thread.terminated.connect(self.threadCleanup) self.alg.moveToThread(self.thread) self.alg.started.connect(self.manageStarted) self.alg.progress.connect(self.manageProgress) self.alg.message.connect(self.manageMessage) self.alg.error.connect(self.manageError) self.alg.finished.connect(self.manageFinished) # set wait cursor and start QgsApplication.instance().setOverrideCursor(QtCore.Qt.WaitCursor) self.thread.start()
def on_btnRun_clicked(self): if self.inputfile == '': QMessageBox.critical(self,'Map Creator', 'Please specify input coordinate file.') return if self.outputfile == '': QMessageBox.critical(self,'Map Creator', 'Please specify output shapefile.') return self.setCursor(Qt.WaitCursor) #Open coordinate input file f = open(self.inputfile, 'r') lines = f.readlines() f.close() header = lines[0].split(',')[0] totfeat = len(lines) - 1 lines.pop(0) lines.reverse() #Create vector layer basename = os.path.basename(self.outputfile) vlayer = QgsVectorLayer("Polygon", basename, "memory") vprovider = vlayer.dataProvider() fld = QgsField(header,QVariant.String) flds = QgsFields() flds.append(fld) vprovider.addAttributes([fld]) vlayer.startEditing() hull = [] for cnt, line in enumerate(lines): line = line.rstrip().split(',') numcoords = int((len(line) - 1) / 2) hull[:] = [] geom = QgsGeometry() feat = QgsFeature() feat.setFields(flds) for i in range(numcoords): hull.append(QgsPoint(float(line[i*2+1]),float(line[i*2+2]))) geom = geom.fromMultiPoint(hull) geom = geom.convexHull() feat.setGeometry(geom) feat.setAttribute(header,str(line[0])) result = vlayer.addFeature(feat) if not result: self.setCursor(Qt.ArrowCursor) QMessageBox.critical(self,'Map Creator', 'Processing error.') return self.ui.ProgressBar.setValue(float(cnt+1)/float(totfeat) * 100.0) QApplication.processEvents() vlayer.commitChanges() vlayer.updateExtents() #Write the output shapefile if os.path.exists(self.outputfile): QgsVectorFileWriter.deleteShapeFile(self.outputfile) result = QgsVectorFileWriter.writeAsVectorFormat(vlayer, self.outputfile, 'utf-8', vlayer.crs()) if result != QgsVectorFileWriter.NoError: QMessageBox.critical(self,'Map Creator','Error creating shapefile.') else: #Ask to add shapfile to map name = QFileInfo(self.outputfile).completeBaseName() result = QMessageBox.question(self,'Map Creator', 'Add shapefile to map?', QMessageBox.Yes, QMessageBox.No) if result == QMessageBox.Yes: self.iface.addVectorLayer(self.outputfile, name, 'ogr') self.setCursor(Qt.ArrowCursor)
def create_layer(self, parameters, name, is_memory, dest_crs, layer_style=None): save_as = parameters.file_path file_format = parameters.file_format # save paramaters serialized = base64.b64encode( parameters.serialize(with_style=False, with_geometry=False)) # save geometry layer = QgsVectorLayer("MultiPolygon?crs=%s" % dest_crs.authid(), name, "memory") pr = layer.dataProvider() layer.startEditing() layer.addAttribute(QgsField("params", QVariant.String)) fet1 = QgsFeature(0) fet1.setFields(layer.fields()) fet1.setAttribute("params", str(serialized)[2:-1]) fet1.setGeometry(parameters.geometry) pr.addFeatures([fet1]) layer.commitChanges() # copy layer style if layer_style is not None: self.set_layer_style(layer, layer_style) if is_memory: return layer if os.path.isfile(save_as): # delete first if already exists if save_as.endswith(".shp"): QgsVectorFileWriter.deleteShapeFile(save_as) else: os.unlink(save_as) # create the disk layer QgsMessageLog.logMessage( "Mask saving '{}' as {}".format(save_as, file_format), "Extensions") error = QgsVectorFileWriter.writeAsVectorFormat( layer, save_as, "System", dest_crs, file_format) if error[0] == 0: QgsMessageLog.logMessage("Error = 0", "Extensions") nlayer = QgsVectorLayer(save_as, name, "ogr") if not nlayer.dataProvider().isValid(): QgsMessageLog.logMessage("Invalid dataProvider", "Extensions") return None if not nlayer.isSpatial(): QgsMessageLog.logMessage("No GeometryType", "Extensions") return None # force CRS nlayer.setCrs(dest_crs) # copy layer style layer_style = self.get_layer_style(layer) self.set_layer_style(nlayer, layer_style) return nlayer else: raise RuntimeError(error) return None