def isWritable(layer): if isInvalid(layer) or len(layer.vectorJoins()) > 0: return False if layer.storageType() == 'ESRI Shapefile': sourceList = layer.source().split('|') shpFile = QFileInfo(sourceList[0]) baseFilePath = shpFile.canonicalPath() + '/' + shpFile.completeBaseName() shxFile = QFileInfo(baseFilePath + '.shx') dbfFile = QFileInfo(baseFilePath + '.dbf') return (shpFile.exists() and shpFile.isWritable() and shxFile.exists() and shxFile.isWritable() and dbfFile.exists() and dbfFile.isWritable()) return True
def isWritable(layer): if isInvalid(layer) or len(layer.vectorJoins()) > 0: return False if layer.storageType() == 'ESRI Shapefile': sourceList = layer.source().split('|') shpFile = QFileInfo(sourceList[0]) baseFilePath = shpFile.canonicalPath( ) + '/' + shpFile.completeBaseName() shxFile = QFileInfo(baseFilePath + '.shx') dbfFile = QFileInfo(baseFilePath + '.dbf') return (shpFile.exists() and shpFile.isWritable() and shxFile.exists() and shxFile.isWritable() and dbfFile.exists() and dbfFile.isWritable()) return True
def _add_raster_layer(self, raster_layer, layer_name): """Add a raster layer to the folder. :param raster_layer: The layer to add. :type raster_layer: QgsRasterLayer :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 """ if not self.is_writable(): return False, 'The destination is not writable.' output = QFileInfo(self.uri.filePath(layer_name + '.tif')) source = QFileInfo(raster_layer.source()) if source.exists() and source.suffix() in ['tiff', 'tif']: # If it's tiff file based. QFile.copy(source.absoluteFilePath(), output.absoluteFilePath()) else: # If it's not file based. renderer = raster_layer.renderer() provider = raster_layer.dataProvider() crs = raster_layer.crs() pipe = QgsRasterPipe() pipe.set(provider.clone()) pipe.set(renderer.clone()) file_writer = QgsRasterFileWriter(output.absoluteFilePath()) file_writer.Mode(1) file_writer.writeRaster( pipe, provider.xSize(), provider.ySize(), provider.extent(), crs) del file_writer assert output.exists() return True, output.baseName()
def restoreDir(self): "用户点击了“默认运行目录”按钮。" path = self.txtPath.text().strip() fi = QFileInfo(path) if path == "" or not fi.exists(): return self.txtDir.setText(fi.dir().absolutePath())
def batchFinished(self): self.base.stop() if len(self.errors) > 0: msg = u"Processing of the following files ended with error: <br><br>" + "<br><br>".join( self.errors) QErrorMessage(self).showMessage(msg) inDir = self.getInputFileName() outDir = self.getOutputFileName() if outDir is None or inDir == outDir: self.outFiles = self.inFiles # load layers managing the render flag to avoid waste of time canvas = self.iface.mapCanvas() previousRenderFlag = canvas.renderFlag() canvas.setRenderFlag(False) notCreatedList = [] for item in self.outFiles: fileInfo = QFileInfo(item) if fileInfo.exists(): if self.base.loadCheckBox.isChecked(): self.addLayerIntoCanvas(fileInfo) else: notCreatedList.append(item) canvas.setRenderFlag(previousRenderFlag) if len(notCreatedList) == 0: QMessageBox.information(self, self.tr("Finished"), self.tr("Operation completed.")) else: QMessageBox.warning( self, self.tr("Warning"), self.tr("The following files were not created: \n{0}").format( ', '.join(notCreatedList)))
def _add_vector_layer(self, vector_layer, layer_name): """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 :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', vector_layer.crs(), driver_mapping[self._default_vector_format]) 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 start_logging (self): if self._logger is not None: return self._logger = logging.getLogger('Logger1') self._logger.setLevel(logging.DEBUG) log_full_path_file_name = '%s/log.log' % os.path.dirname(os.path.realpath(__file__)) log_file_info = QFileInfo(log_full_path_file_name) if log_file_info.exists(): log_created_qdatetime = log_file_info.created() current_qdatetime = QDateTime.currentDateTime() max_difference_secs = 60 * 60 * 24 * 7 # 7 giorni current_difference_secs = log_created_qdatetime.secsTo(current_qdatetime) if current_difference_secs > max_difference_secs: QFile.remove(log_full_path_file_name) self._log_handler = LogHandler(log_full_path_file_name) formatter = logging.Formatter('%(asctime)s - %(thread)d - %(name)s - %(levelname)s - %(message)s') self._log_handler.setFormatter(formatter) self._logger.addHandler(self._log_handler) # Do not raise logging system exceptions logging.raiseExceptions = False # Connect log signal self._log_handler.logged.connect (self.message_logged) self.logging_enabled = True
def batchFinished( self ): self.base.stop() if len(self.errors) > 0: msg = u"Processing of the following files ended with error: <br><br>" + "<br><br>".join( self.errors ) QErrorMessage( self ).showMessage( msg ) inDir = self.getInputFileName() outDir = self.getOutputFileName() if outDir is None or inDir == outDir: self.outFiles = self.inFiles # load layers managing the render flag to avoid waste of time canvas = self.iface.mapCanvas() previousRenderFlag = canvas.renderFlag() canvas.setRenderFlag( False ) notCreatedList = [] for item in self.outFiles: fileInfo = QFileInfo( item ) if fileInfo.exists(): if self.base.loadCheckBox.isChecked(): self.addLayerIntoCanvas( fileInfo ) else: notCreatedList.append( item ) canvas.setRenderFlag( previousRenderFlag ) if len( notCreatedList ) == 0: QMessageBox.information( self, self.tr( "Finished" ), self.tr( "Operation completed." ) ) else: QMessageBox.warning( self, self.tr( "Warning" ), self.tr( "The following files were not created: \n{0}" ).format( ', '.join( notCreatedList ) ) )
def _loadLayer(self): fullLayerPath = os.path.join(self._projectPath, self._settings.path) filePath = QFileInfo(fullLayerPath) layer = None if filePath.exists(): layer = layers.loadShapefileLayer(fullLayerPath, self._settings.name) else: wkbType = layers.geometryToWkbType(self._settings.geometry, self._settings.multi) if not filePath.dir().exists(): os.makedirs(filePath.dir().absolutePath()) layer = layers.createShapefile(fullLayerPath, self._settings.name, wkbType, self._settings.crs, self.fields) if layer and layer.isValid(): layer = layers.addLayerToLegend(self._iface, layer) self._setDefaultSnapping(layer) layer.loadNamedStyle(self._settings.stylePath) self.name = self._settings.name self.layer = layer self.layerId = layer.id() else: self.layer = None self.layerId = ''
def _loadLogLayer(self): fullLayerPath = os.path.join(self._projectPath, self._settings.logPath) filePath = QFileInfo(fullLayerPath) layer = None if filePath.exists(): layer = layers.loadShapefileLayer(fullLayerPath, self._settings.logName) else: if not filePath.dir().exists(): os.makedirs(filePath.dir().absolutePath()) fields = QgsFields() fields.append(QgsField('timestamp', QVariant.String, '', 10, 0, 'timestamp')) fields.append(QgsField('event', QVariant.String, '', 6, 0, 'event')) fields.extend(self.fields) layer = layers.createShapefile(fullLayerPath, self._settings.logName, self.layer.wkbType(), self._settings.crs, fields) if layer and layer.isValid(): layer.editFormConfig().setSuppress(QgsEditFormConfig.SuppressOn) self.logLayer = layer self.logLayerId = layer.id() else: self.logLayer = None self.logLayerId = ''
def lastModified(self, path): fi = QFileInfo(path) if fi.exists(): return fi.lastModified() else: err = 'No such file or directory' qDebug("FileSystem.lastModified - %s: '%s'" % (err, path)) return QDateTime()
def setFileIcon(self, path): "每当txtPath的值改变时,就设置快捷方式的图标" fi = QFileInfo(path) if not fi.exists(): self.shortcutIcon = QIcon(":/images/unknown.png") else: ip = QFileIconProvider() self.shortcutIcon = ip.icon(fi) self.btnFace.setIcon(self.shortcutIcon)
def on_mEndMarkerLineEdit_textChanged(self, text): if (self.mArrow): self.mArrow.beginCommand(QString("Arrow end marker")) fi = QFileInfo(text) if (fi.exists() and fi.isFile()): self.mArrow.setEndMarker(text) else: self.mArrow.setEndMarker("") self.mArrow.update() self.mArrow.endCommand()
def smethod_0(parent, inputFilePath, crcCalcMethodStr=None): flag = False dlgCrcCheck = DlgCrcCheck(parent) dlgCrcCheck.crcCalcMethodStr = crcCalcMethodStr contents = None try: with open(inputFilePath, 'rb', 0) as tempFile: contents = tempFile.read() tempFile.close() except: return False bytes = FasDataBlockFile.CRC_Calculation(contents) string_0 = QString(inputFilePath) crcFileDir = string_0.left(string_0.length() - 3) + "crc" fileInfo = QFileInfo(crcFileDir) if not fileInfo.exists(): if QMessageBox.warning( dlgCrcCheck, "Warning", "CRC file is not existing.\nDo you want to create the CRC file for this file?", QMessageBox.Yes | QMessageBox.No) == QMessageBox.No: return False contents = None # with open(inputFilePath, 'rb', 0) as tempFile: # contents = tempFile.read() # tempFile.flush() # tempFile.close() # bytes = FasDataBlockFile.CRC_Calculation(contents) # string_0 = QString(inputFilePath) # path = string_0.left(string_0.length() - 3) + "crc" fileStream = open(crcFileDir, 'wb') fileStream.write(bytes) fileStream.close() crcFileContents = None with open(crcFileDir, 'rb', 0) as tempFileCrc: crcFileContents = tempFileCrc.read() tempFileCrc.close() if bytes != crcFileContents: dlgCrcCheck.pnlCalculatedCrcValue.textBox.setStyleSheet( "color: rgb(255, 0, 0);") else: dlgCrcCheck.pnlCalculatedCrcValue.textBox.setStyleSheet( "color: rgb(0, 0, 0);") dlgCrcCheck.pnlSuppliedCrcValue.Value = crcFileContents dlgCrcCheck.pnlCalculatedCrcValue.Value = bytes resultDlg = dlgCrcCheck.exec_() if (resultDlg == 0): flag = False else: flag = True return flag
def method_30(self): filePath = define.appPath + "/Resource/settingData/phxtemplates.xml" fileInfo = QFileInfo(filePath) if fileInfo.exists(): QFile.remove(filePath) doc = QDomDocument() rootElem = doc.createElement("Templates") xmlDeclaration = doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"utf-8\"") doc.appendChild(xmlDeclaration) for i in range(self.parametersPanel.gridModel.rowCount()): elem = doc.createElement( "Templates" + self.parametersPanel.gridModel.item(i, 0).text()) valueElem = doc.createElement("title") valueElem.appendChild( doc.createTextNode( self.parametersPanel.gridModel.item(i, 0).text())) elem.appendChild(valueElem) valueElem = doc.createElement("space") valueElem.appendChild( doc.createTextNode( self.parametersPanel.gridModel.item(i, 1).text())) elem.appendChild(valueElem) valueElem = doc.createElement("value") valueElem.appendChild( doc.createTextNode( self.parametersPanel.gridModel.item(i, 2).text())) elem.appendChild(valueElem) rootElem.appendChild(elem) doc.appendChild(rootElem) qFile = QFile(filePath) if qFile.open(QFile.WriteOnly): textStream = QTextStream(qFile) doc.save(textStream, 4) qFile.close() # ###CRC file is created. contents = None with open(filePath, 'rb', 0) as tempFile: contents = tempFile.read() tempFile.flush() tempFile.close() bytes = FasDataBlockFile.CRC_Calculation(contents) string_0 = QString(filePath) path = string_0.left(string_0.length() - 3) + "crc" fileStream = open(path, 'wb') fileStream.write(bytes) fileStream.close()
def addShapeToCanvas(shapefile_path): file_info = QFileInfo(shapefile_path) if file_info.exists(): layer_name = file_info.completeBaseName() else: return False vlayer_new = QgsVectorLayer(shapefile_path, layer_name, "ogr") if vlayer_new.isValid(): QgsMapLayerRegistry.instance().addMapLayers([vlayer_new]) return True else: return False
def userResourcePath(cls) -> str: configDir = QFileInfo(cls.settings(QSettings.UserScope).fileName()).path() urp = configDir + "/medux" # TODO: make this more pythonic fi = QFileInfo(urp + "/") if not fi.exists(): dir = QDir() if not dir.mkpath(urp): warnings.warn("could not create {}".format(urp)) return urp
def __workingDirectory(path_): """ Private function to determine working directory for the file dialog. @param path_ path of the intended working directory (string or QString) @return calculated working directory (QString) """ path = QString(path_) if not path.isEmpty(): info = QFileInfo(path) if info.exists() and info.isDir(): return info.absoluteFilePath() return info.absolutePath() return QDir.currentPath()
def newFile(self, bookPath): if not bookPath.isNull(): # this was successful File>Open finf = QFileInfo(bookPath) self.pngPath = finf.absolutePath().append(u"/pngs/") finf = QFileInfo(self.pngPath) if finf.exists() and finf.isDir(): # looking good self.ready = True self.newPosition() else: # We could inform the user we couldn't find a pngs folder, # but you know -- the user is probably already aware of that. self.clear() # just put up the gray default image else: # It was a File>New self.clear()
def finished( self ): outFn = self.getOutputFileName() if self.needOverwrite: oldFile = QFile( outFn ) newFile = QFile( self.tempFile ) if oldFile.remove(): newFile.rename( outFn ) fileInfo = QFileInfo( outFn ) if fileInfo.exists(): if self.base.loadCheckBox.isChecked(): self.addLayerIntoCanvas( fileInfo ) QMessageBox.information( self, self.tr( "Finished" ), self.tr( "Processing completed." ) ) else: QMessageBox.warning( self, self.tr( "Warning" ), self.tr( "{0} not created." ).format( outFn ) )
def finished(self): outFn = self.getOutputFileName() if self.needOverwrite: oldFile = QFile(outFn) newFile = QFile(self.tempFile) if oldFile.remove(): newFile.rename(outFn) fileInfo = QFileInfo(outFn) if fileInfo.exists(): if self.base.loadCheckBox.isChecked(): self.addLayerIntoCanvas(fileInfo) QMessageBox.information(self, self.tr("Finished"), self.tr("Processing completed.")) else: QMessageBox.warning(self, self.tr("Warning"), self.tr("{0} not created.").format(outFn))
def finished(self, load): outFn = self.getOutputFileName() if outFn is None: return if outFn == '': QMessageBox.warning(self, self.tr("Warning"), self.tr("No output file created.")) return fileInfo = QFileInfo(outFn) if fileInfo.exists(): if load: self.addLayerIntoCanvas(fileInfo) QMessageBox.information(self, self.tr("Finished"), self.tr("Processing completed.")) else: #QMessageBox.warning(self, self.tr( "Warning" ), self.tr( "%1 not created." ).arg( outFn ) ) QMessageBox.warning(self, self.tr("Warning"), self.tr("%s not created.") % outFn)
def on_open(self): '''打开现有配置''' fileName = QFileDialog.getOpenFileName( self, "选择现有模板", app.g_pwd + os.sep + "configurations", "Config (*.json)") if fileName.isEmpty(): return self.path = fileName with open(app.QString2str(fileName), 'r') as f: content = f.read() fileInfo = QFileInfo(fileName) if not fileInfo.exists(): return config = Configuration() config.fromJson(content) config.allone_dir = os.getenv('ALLONEDIR', '../..').replace('\\', '/') self.addConfig(fileInfo.baseName(), fileInfo.filePath(), content) self.on_select()
def layer_uri(self, layer_name): """Get layer URI. :param layer_name: The name of the layer to fetch. :type layer_name: str :return: The URI to the layer. :rtype: str .. versionadded:: 4.0 """ layers = self.layers() for layer, extension in product(layers, EXTENSIONS): one_file = QFileInfo(self.uri.filePath(layer + '.' + extension)) if one_file.exists(): if one_file.baseName() == layer_name: return one_file.absoluteFilePath() else: return None
def layer_uri(self, layer_name): """Get layer URI. :param layer_name: The name of the layer to fetch. :type layer_name: str :return: The URI to the layer. :rtype: str .. versionadded:: 4.0 """ layers = self.layers() for layer, extension in product(layers, EXTENSIONS): one_file = QFileInfo( self.uri.filePath(layer + '.' + extension)) if one_file.exists(): if one_file.baseName() == layer_name: return one_file.absoluteFilePath() else: return None
def pnlFileEvent_1(self): inputFilePath = QFileDialog.getOpenFileName( self, "Open Xml File", QCoreApplication.applicationDirPath(), "Xml Files (*.xml)") if inputFilePath == "": return fileInfo = QFileInfo(inputFilePath) self.pnlFile.Value = fileInfo.fileName() contents = None with open(inputFilePath, 'rb', 0) as tempFile: contents = tempFile.read() tempFile.close() bytes = FasDataBlockFile.CRC_Calculation(contents) string_0 = QString(inputFilePath) crcFileDir = string_0.left(string_0.length() - 3) + "crc" fileInfo = QFileInfo(crcFileDir) if self.rwFlag == "r": if not fileInfo.exists(): QMessageBox.warning(self, "Warning", "CRC file is not existing.") return crcFileContents = None with open(crcFileDir, 'rb', 0) as tempFileCrc: crcFileContents = tempFileCrc.read() tempFileCrc.close() if bytes != crcFileContents: self.pnlCalculatedCrcValue.textBox.setStyleSheet( "color: rgb(255, 0, 0);") else: self.pnlCalculatedCrcValue.textBox.setStyleSheet( "color: rgb(0, 0, 0);") self.pnlSuppliedCrcValue.Value = crcFileContents self.pnlCalculatedCrcValue.Value = bytes else: fileStream = open(crcFileDir, 'wb') fileStream.write(bytes) fileStream.close() self.pnlCalculatedCrcValue.Value = bytes
def set_source_document_location(doc_path): """ Set the latest source directory of uploaded source documents. :param doc_path: Directory path or file path. The system will attempt to extract the directory path from the file name. """ doc_dir_path = "" #Check if it is a file or directory doc_dir = QDir(doc_path) if not doc_dir.exists(): doc_file_info = QFileInfo(doc_path) if doc_file_info.exists(): doc_dir_path = doc_file_info.dir().path() else: doc_dir_path = doc_path if len(doc_dir_path) > 0: reg_config = RegistryConfig() reg_config.write({LOCAL_SOURCE_DOC:doc_dir_path})
def _loadBufferLayer(self): fullLayerPath = os.path.join(self._projectPath, self._settings.bufferPath) filePath = QFileInfo(fullLayerPath) layer = None if filePath.exists(): layer = layers.loadShapefileLayer(fullLayerPath, self._settings.bufferName) else: if not filePath.dir().exists(): os.makedirs(filePath.dir().absolutePath()) layer = layers.cloneAsShapefile(self.layer, fullLayerPath, self._settings.bufferName) if layer and layer.isValid(): layer = layers.addLayerToLegend(self._iface, layer) self._setDefaultSnapping(layer) layers.loadStyle(layer, fromLayer=self.layer) layer.startEditing() layer.editFormConfig().setSuppress(QgsEditFormConfig.SuppressOn) self.bufferLayer = layer self.bufferLayerId = layer.id() else: self.bufferLayer = None self.bufferLayerId = ''
def _update_path(self): if not self._use_suffix: self._viewer.set_path(self._current_path) return self._viewer.reset_path() if not self._current_path: return selected_file = QFileInfo(self._current_path) if not selected_file.exists(): return selected_dir = selected_file.absoluteDir() file_name = selected_file.fileName() if not selected_dir.exists(): return if not selected_dir.cd('converted'): return suffixed_path = selected_dir.absoluteFilePath(file_name) self._viewer.set_path(suffixed_path)
def createDb(self, fileName): '''Create a new spatialite database file :param fileName: the filename of the database file :returns: True if the file could be created :rtype: bool ''' try: db = sqlite.connect(fileName) cur = db.cursor() except OperationalError: self.bar.pushMessage(self.tr("SpatiaLite Database"), self.tr("Unable to create database file!"), level=QgsMessageBar.CRITICAL) return False try: db.enable_load_extension(True) except OperationalError: self.bar.pushMessage(self.tr("SpatiaLite Database"), self.tr("SQLITE Load_extension off!"), level=QgsMessageBar.INFO) cur.execute("Select initspatialmetadata(1)") db.commit() db.close fi = QFileInfo(fileName) if not fi.exists(): return False key = u'/SpatiaLite/connections/' + fi.fileName() + u'/sqlitepath' settings = QSettings() if not settings.contains(key): settings.setValue('/SpatiaLite/connections/selected', fi.fileName() + self.tr('@') + fi.canonicalFilePath()) settings.setValue(key, fi.canonicalFilePath()) self.bar.pushMessage(self.tr("SpatiaLite Database"), self.tr("Registered new database!"), level=QgsMessageBar.SUCCESS) return True
def addImages(): def finished(msg=None): if not msg is None: self.messageStatus.emit(msg) self.finished.emit(self.isKilled) def getFileInfo(image): def prepareFileTMS(url_tms): def createLocalFile(): def populateLocalFile(): html = response.read() response.close() fw = open(localName, 'w') fw.write(html) fw.close() isOk = True try: response = urllib2.urlopen(url_tms) except urllib2.HTTPError, e: isOk = False except urllib2.URLError, e: isOk = False # if not isOk: return QFileInfo(url_tms) # Add for error list else: populateLocalFile() return QFileInfo(localName) localName = "%s/%s" % (self.TEMP_DIR, basename(url_tms)) fileInfo = QFileInfo(localName) if not fileInfo.exists(): fileInfo = createLocalFile() return fileInfo
def test_create_geopackage(self): """Test if we can store geopackage.""" # Create a geopackage from an empty file. path = QFileInfo(mktemp() + '.gpkg') self.assertFalse(path.exists()) data_store = GeoPackage(path) path.refresh() self.assertTrue(path.exists()) # Let's add a vector layer. layer_name = 'flood_test' layer = standard_data_path('hazard', 'flood_multipart_polygons.shp') vector_layer = QgsVectorLayer(layer, 'Flood', 'ogr') result = data_store.add_layer(vector_layer, layer_name) self.assertTrue(result[0]) # We should have one layer. layers = data_store.layers() self.assertEqual(len(layers), 1) self.assertIn(layer_name, layers) # Add the same layer with another name. layer_name = 'another_vector_flood' result = data_store.add_layer(vector_layer, layer_name) self.assertTrue(result[0]) # We should have two layers. layers = data_store.layers() self.assertEqual(len(layers), 2) self.assertIn(layer_name, layers) # Test the URI of the new layer. expected = path.absoluteFilePath() + '|layername=' + layer_name self.assertEqual(data_store.layer_uri(layer_name), expected) # Test a fake layer. self.assertIsNone(data_store.layer_uri('fake_layer')) # Test to add a raster layer_name = 'raster_flood' layer = standard_data_path('hazard', 'classified_hazard.tif') raster_layer = QgsRasterLayer(layer, layer_name) result = data_store.add_layer(raster_layer, layer_name) self.assertTrue(result[0]) # We should have 3 layers inside. layers = data_store.layers() self.assertEqual(len(layers), 3) # Check the URI for the raster layer. expected = 'GPKG:' + path.absoluteFilePath() + ':' + layer_name self.assertEqual(data_store.layer_uri(layer_name), expected) # Add a second raster. layer_name = 'big raster flood' self.assertTrue(data_store.add_layer(raster_layer, layer_name)) self.assertEqual(len(data_store.layers()), 4) # Test layer without geometry layer = load_test_vector_layer( 'gisv4', 'impacts', 'exposure_summary_table.csv') tabular_layer_name = 'breakdown' result = data_store.add_layer(layer, tabular_layer_name) self.assertTrue(result[0])
def addStyleLayerQuery(): def getStyleDB(): drv_conn = f_connections[ name ]( uri ) cur = drv_conn['conn'].cursor() # result = runSQL( drv_conn[ 'sqlStyleTable' ], cur, drv_conn ) if not result[ 'isOk']: return result # hasTable = False if cur.fetchone() is None else True if hasTable is None: data = ( self.nameLayerSQL, drv_conn[ 'tableStyle' ] ) msg = "Error in query '%s' (for verify style). Not exist table '%s'!" % data return { 'isOk': True, 'exits': False, 'msg': msg } # data = ( drv_conn[ 'tableStyle' ], self.styleLayerSQL ) sql = "SELECT styleQML FROM %s WHERE styleName = '%s'" % data result = runSQL( sql, cur, drv_conn ) if not result[ 'isOk']: return result # value = cur.fetchone() if value is None: data = ( self.nameLayerSQL, self.styleLayerSQL, rv_conn[ 'tableStyle' ] ) msg = "Error in query '%s' (for verify style). Not exist style '%s' in table '%s'!" % data return { 'isOk': True, 'exits': False, 'msg': msg } # cur.close() drv_conn['conn'].close() # return { 'isOk': True, 'exits': True, 'qml': value[0] } # def setStyleLayer(qml): qmlFile = "%saddlayersql_action_temp.qml" % ( QgsApplication.qgisSettingsDirPath() ) if os.path.exists(qmlFile): os.remove( qmlFile ) f = codecs.open( qmlFile, 'w', encoding='utf8') f.write( qml ) f.close() # layerQuery.loadNamedStyle( qmlFile ) # os.remove( qmlFile ) if self.styleLayerSQL is None: return # File fileStyle = QFileInfo( self.styleLayerSQL ) if fileStyle.exists() and fileStyle.isFile(): layerQuery.loadNamedStyle( self.styleLayerSQL ) return # DB *** Had self.styleLayerSQL and not is file -> Need be a DB result = getStyleDB() if not result['isOk'] or not result['exits']: rb = self._addHighlightGeom() self.msgBar.pushMessage( self.nameModulus, result['msg'], QgsMessageBar.WARNING, 5 ) self._removeHighlightGeom( rb, 5 ) return # setStyleLayer( result['qml'] )
class Georeferencer(QObject): # Step enum Start = 0 Crop = 1 Translate = 2 Warp = 3 Overview = 4 Stop = 5 Step = [0, 1, 2, 3, 4, 5] Label = ['Start', 'Crop', 'Translate', 'Warp', 'Overview', 'Stop'] # Georeferencer.Step, ProcessStatus status = pyqtSignal(int, int) # Georeferencer.Step, Message error = pyqtSignal(int, str) def __init__(self, parent=None): super(Georeferencer, self).__init__(parent) # Internal variables self._debug = True self._gdalDir = QDir() self._step = 0 self._status = 0 self._translate = QFileInfo() self._warp = QFileInfo() self._overview = QFileInfo() self._command = '' self._args = '' self._process = QProcess() self._gc = Transform() self._rawFile = QFileInfo() self._pointFile = QFileInfo() self._cropFile = QFileInfo() self._translateFile = QFileInfo() self._geoFile = QFileInfo() tempDir = QDir.temp() self._cropFile.setFile( tempDir.absoluteFilePath('.ark_georef_crop.png')) self._translateFile = QFileInfo( tempDir.absoluteFilePath('.ark_georef_translate.tiff')) self._gdalDir = QDir(self.gdalPath()) if self._debug: debug('GDAL Path: ' + self._gdalDir.absolutePath()) self._translate.setFile(self._gdalDir, 'gdal_translate') self._warp.setFile(self._gdalDir, 'gdalwarp') self._overview.setFile(self._gdalDir, 'gdaladdo') if (not self._translate.exists() or not self._warp.exists() or not self._overview.exists()): self._signalError( 'GDAL commands not found, please ensure GDAL Tools plugin is installed and has correct path set!' ) return self._process.started.connect(self._processStarted) self._process.finished.connect(self._processFinished) self._process.error.connect(self._processError) self._process.readyReadStandardError.connect(self._processError) def step(self): return self._step def processStatus(self): return self._status def run(self, gc, rawFile, pointFile, geoFile): self._step = Georeferencer.Start if (not gc.isValid()): self._signalError('Invalid ground control points.') return self._gc = gc if (not rawFile.exists()): self._signalError('Raw file not found.') return self._rawFile = rawFile self._pointFile = pointFile self._geoFile = geoFile if not self._geoFile.absoluteDir().exists(): self._geoFile.absoluteDir().mkpath('.') if (self._debug): debug('Raw File: \'' + self._rawFile.absoluteFilePath() + '\'') debug('GCP File: \'' + self._pointFile.absoluteFilePath() + '\'') debug('Crop File: \'' + self._cropFile.absoluteFilePath() + '\'') debug('Translate File: \'' + self._translateFile.absoluteFilePath() + '\'') debug('Geo File: \'' + self._geoFile.absoluteFilePath() + '\'') QCoreApplication.processEvents() self._runCropStep() def _runCropStep(self): if self._debug: debug('Crop') self._step = Georeferencer.Crop self._args = [] self._command = '' pixmap = QPixmap(self._rawFile.absoluteFilePath()) if pixmap.isNull(): self._signalError('Loading of raw image failed.') return pixmap = pixmap.copy(0, 0, pixmap.width(), int(pixmap.height() * 0.84)) image = pixmap.toImage() if image.isNull(): self._signalError('Cropping of raw image failed.') return if not image.save(self._cropFile.absoluteFilePath(), 'PNG', 100): self._signalError('Saving of cropped image failed.') return self._signalStatus() self._runTranslateStep() def _formatGcp(self, point): point = self._gc.point(point) return "{0:f} {1:f} {2:f} {3:f}".format(point.raw().x(), point.raw().y(), point.map().x(), point.map().y()) def _runTranslateStep(self): self._step = Georeferencer.Translate self._args = [] self._args.extend(['-of', 'GTiff']) self._args.extend(['-a_srs', self._gc.crs]) # self._args.extend(['-gcp', self._formatGcp(1)]) # self._args.extend(['-gcp', self._formatGcp(2)]) # self._args.extend(['-gcp', self._formatGcp(3)]) # self._args.extend(['-gcp', self._formatGcp(4)]) self._args.extend([ '-gcp', str(self._gc.point(1).raw().x()), str(self._gc.point(1).raw().y()), str(self._gc.point(1).map().x()), str(self._gc.point(1).map().y()) ]) self._args.extend([ '-gcp', str(self._gc.point(2).raw().x()), str(self._gc.point(2).raw().y()), str(self._gc.point(2).map().x()), str(self._gc.point(2).map().y()) ]) self._args.extend([ '-gcp', str(self._gc.point(3).raw().x()), str(self._gc.point(3).raw().y()), str(self._gc.point(3).map().x()), str(self._gc.point(3).map().y()) ]) self._args.extend([ '-gcp', str(self._gc.point(4).raw().x()), str(self._gc.point(4).raw().y()), str(self._gc.point(4).map().x()), str(self._gc.point(4).map().y()) ]) self._args.append(self._cropFile.absoluteFilePath()) self._args.append(self._translateFile.absoluteFilePath()) self._command = self._translate.absoluteFilePath() + ' ' + ' '.join( self._args) self._process.start(self._translate.absoluteFilePath(), self._args) def _runWarpStep(self): self._step = Georeferencer.Warp self._args = [] self._args.extend(['-order', '1']) self._args.extend(['-r', 'cubic']) self._args.extend(['-t_srs', self._gc.crs]) self._args.extend(['-of', 'GTiff']) self._args.extend(['-co', 'COMPRESS=JPEG']) self._args.extend(['-co', 'JPEG_QUALITY=50']) self._args.extend(['-co', 'TILED=YES']) self._args.append('-dstalpha') self._args.append('-overwrite') self._args.append('\"' + self._translateFile.absoluteFilePath() + '\"') self._args.append('\"' + self._geoFile.absoluteFilePath() + '\"') self._command = self._warp.absoluteFilePath() + ' ' + ' '.join( self._args) self._process.start(self._command) def _runOverviewStep(self): self._step = Georeferencer.Overview self._args = [] self._args.extend(['--config', 'COMPRESS_OVERVIEW JPEG']) self._args.extend(['--config', 'INTERLEAVE_OVERVIEW PIXEL']) self._args.extend(['-r', 'cubic']) self._args.append('\"' + self._geoFile.absoluteFilePath() + '\"') self._args.append('2 4 8 16') self._command = self._overview.absoluteFilePath() + ' ' + ' '.join( self._args) self._process.start(self._command) def _processStarted(self): self._status = ProcessStatus.Running self._signalStatus() if self._debug: debug(self.Label[self._step]) debug(self._command) def _processFinished(self): self._status = ProcessStatus.Success self._signalStatus() if (self._step == Georeferencer.Translate): self._runWarpStep() elif (self._step == Georeferencer.Warp): self._runOverviewStep() elif (self._step == Georeferencer.Overview): self.writeGcpFile(self._gc, self._pointFile.absoluteFilePath()) self._step = Georeferencer.Stop self._signalStatus() def _processError(self): self._status = ProcessStatus.Failure msg = str(self._process.readAllStandardError()) debug(msg) self._signalError(msg) def _signalStatus(self): self.status.emit(self._step, self._status) def _signalError(self, msg): self.error.emit(self._step, msg) @staticmethod def gdalPath(): return QSettings().value('/GdalTools/gdalPath', '/usr/bin') @staticmethod def loadGcpFile(path): inFile = QFile(path) if (not inFile.open(QIODevice.ReadOnly | QIODevice.Text)): return 'ERROR: Unable to open GCP file for reading' inStream = QTextStream(inFile) line = inStream.readLine() # Skip the header line if found if (line == 'mapX,mapY,pixelX,pixelY,enable'): line = inStream.readLine() lines = 0 gc = Transform() while (line): lines += 1 vals = line.split(',') if (len(vals) != 5): return None map = QgsPoint(float(vals[0]), float(vals[1])) raw = QPointF(float(vals[2]), float(vals[3])) enabled = bool(vals[4]) point = GroundControlPoint(raw, map, enabled) gc.setPoint(lines, point) line = inStream.readLine() inFile.close() return gc @staticmethod def writeGcpFile(gc, path): outFile = QFile(path) if (not outFile.open(QIODevice.WriteOnly | QIODevice.Text)): return 'Unable to open GCP file for writing' outStream = QTextStream(outFile) outStream << gc.asCsv() outFile.close()