def _run_loading_vfk_layer(self, filePath): """Calls methods for loading a VFK layer. Disables loading widgets until the loading is finished. Args: filePath (str): A full path to the file. """ try: self.set_value_loadVfkProgressBar.emit(0) fileInfo = QFileInfo(filePath) dbPath = QDir(fileInfo.absolutePath())\ .filePath(fileInfo.completeBaseName() + '.db') layerCode = self.dW.parLayerCode vfkDriverName = 'VFK' layerName = fileInfo.completeBaseName() + '|' + layerCode self._create_db_file(filePath, dbPath, layerCode, vfkDriverName) self._open_database(dbPath) # SpatiaLite fix - start if not self.dW.fixedSqliteDriver: dbPath = self._create_spatialite_db_file(dbPath) # SpatiaLite fix - end self._load_vfk_layer(dbPath, layerName, layerCode, vfkDriverName) self.loadVfkProgressBar.setMaximum(1) self.set_value_loadVfkProgressBar.emit(1) self.set_text_statusbar.emit(u'Data byla úspešně načtena.', 0, False) except self.dW.puError: QgsApplication.processEvents() except: QgsApplication.processEvents() self.dW.display_error_messages( self, u'Error loading VFK file "{}".'.format(filePath), u'Chyba při načítání VFK souboru.', u'Chyba při načítání VFK souboru "{}".'.format(filePath)) finally: QgsApplication.processEvents() self._enable_load_widgets(True)
def getSize(layer): """Get layer size on disk""" is_zip_file = False file_path = layer.dataProvider().dataSourceUri() if file_path.find('|') != -1: file_path = file_path[0:file_path.find('|')] if file_path.startswith('/vsizip/'): file_path = file_path.replace('/vsizip/', '') is_zip_file = True _file = QFile(file_path) file_info = QFileInfo(_file) dirname = file_info.dir().absolutePath() filename = file_info.completeBaseName() size = 0 if layer.storageType() == 'ESRI Shapefile' and not is_zip_file: for suffix in ['.shp', '.dbf', '.prj', '.shx']: _file = QFile(os.path.join(dirname, filename + suffix)) file_info = QFileInfo(_file) size = size + file_info.size() elif layer.storageType() in ['GPX', 'GeoJSON', 'LIBKML'] or is_zip_file: size = size + file_info.size() return size
def __init__(self, methodName): """Run once on class initialisation.""" unittest.TestCase.__init__(self, methodName) myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif') rasterFileInfo = QFileInfo(myPath) mRasterLayer = QgsRasterLayer(rasterFileInfo.filePath(), rasterFileInfo.completeBaseName()) rasterRenderer = QgsMultiBandColorRenderer(mRasterLayer.dataProvider(), 2, 3, 4) mRasterLayer.setRenderer(rasterRenderer) #pipe = mRasterLayer.pipe() #assert pipe.set(rasterRenderer), 'Cannot set pipe renderer' QgsMapLayerRegistry.instance().addMapLayers([mRasterLayer]) # create composition with composer map self.mMapRenderer = QgsMapRenderer() layerStringList = [] layerStringList.append(mRasterLayer.id()) self.mMapRenderer.setLayerSet(layerStringList) self.mMapRenderer.setProjectionsEnabled(False) self.mComposition = QgsComposition(self.mMapRenderer) self.mComposition.setPaperSize(297, 210) self.mComposerMap = QgsComposerMap(self.mComposition, 20, 20, 200, 100) self.mComposerMap.setFrameEnabled(True) self.mComposition.addComposerMap(self.mComposerMap)
def csv_vector_layer(csv_path, **kwargs): """ Create a vector layer from a CSV file. :param csv_path: Path of the CSV file. :type csv_path: str :param kwargs: :return: Returns a QGIS memory layer containing the CSV data. :rtype: QgsVectorLayer """ # Get file name csv_fi = QFileInfo(csv_path) layer_name = csv_fi.completeBaseName() delimiter = kwargs.pop('delimiter', ',') # Construct URL with CSV provider query items url = QUrl.fromLocalFile(csv_path) url.addQueryItem('type', 'csv') url.addQueryItem('delimiter', delimiter) url.addQueryItem('geomType', 'none') url.addQueryItem('subsetIndex', 'no') url.addQueryItem('watchFile', 'no') uri = url.toEncoded().data() csv_vl = QgsVectorLayer(uri, layer_name, 'delimitedtext') fields = csv_vl.fields() return csv_vl
def __init__(self, methodName): """Run once on class initialisation.""" unittest.TestCase.__init__(self, methodName) myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif') rasterFileInfo = QFileInfo(myPath) mRasterLayer = QgsRasterLayer(rasterFileInfo.filePath(), rasterFileInfo.completeBaseName()) rasterRenderer = QgsMultiBandColorRenderer( mRasterLayer.dataProvider(), 2, 3, 4) mRasterLayer.setRenderer(rasterRenderer) #pipe = mRasterLayer.pipe() #assert pipe.set(rasterRenderer), 'Cannot set pipe renderer' QgsMapLayerRegistry.instance().addMapLayers([mRasterLayer]) # create composition with composer map self.mMapRenderer = QgsMapRenderer() layerStringList = QStringList() layerStringList.append(mRasterLayer.id()) self.mMapRenderer.setLayerSet(layerStringList) self.mMapRenderer.setProjectionsEnabled(False) self.mComposition = QgsComposition(self.mMapRenderer) self.mComposition.setPaperSize(297, 210) self.mComposerMap = QgsComposerMap(self.mComposition, 20, 20, 200, 100) self.mComposerMap.setFrameEnabled(True) self.mComposition.addComposerMap(self.mComposerMap)
def __init__(self, mainwindow): self.mainwindow = mainwindow # create map canvas self.canvas = QgsMapCanvas(self.mainwindow.widgetMap) self.canvas.setCanvasColor(Qt.yellow) self.canvas.enableAntiAliasing(True) self.canvas.useQImageToRender(False) self.canvas.show() self.canvas.parentWin = mainwindow debugString = QString("Finished Loading Canvas...") self.mainwindow.statusbar.showMessage(debugString) # lay our widgets out in the main window self.layout = QVBoxLayout(self.mainwindow.widgetMap) self.layout.addWidget(self.canvas) # Link in the map tools QObject.connect(self.mainwindow.mpActionZoomIn, SIGNAL("triggered()"), self.zoomIn) QObject.connect(self.mainwindow.mpActionZoomOut, SIGNAL("triggered()"), self.zoomOut) QObject.connect(self.mainwindow.mpActionPan, SIGNAL("triggered()"), self.pan) # Map tools self.toolPan = QgsMapToolPan(self.canvas) self.toolPan.setAction(self.mainwindow.mpActionPan) self.toolZoomIn = QgsMapToolZoom(self.canvas, False) self.toolZoomIn.setAction(self.mainwindow.mpActionZoomIn) self.toolZoomOut = QgsMapToolZoom(self.canvas, True) self.toolZoomOut.setAction(self.mainwindow.mpActionZoomOut) ##### Lets test out a simple map self.layers = [] f = "data/st99_d00.shp" f_string = QString(f) info = QFileInfo(QString(f)) # create layer layer = QgsVectorLayer(QString(f), info.completeBaseName(), "ogr") if not layer.isValid(): # Deal with the error debugString = QString("Error Loading Layer...") self.mainwindow.statusbar.showMessage(debugString) return QgsMapLayerRegistry.instance().addMapLayer(layer) # set extent to the extent of our layer self.canvas.setExtent(layer.extent()) # Set the transparency for the layer #layer.setTransparency(190) # set the map canvas layer set cl = QgsMapCanvasLayer(layer) self.layers.insert(0, cl) self.canvas.setLayerSet(self.layers)
def __init__(self, mainwindow): self.mainwindow = mainwindow # create map canvas self.canvas = QgsMapCanvas(self.mainwindow.widgetMap) self.canvas.setCanvasColor(Qt.yellow) self.canvas.enableAntiAliasing(True) self.canvas.useQImageToRender(False) self.canvas.show() self.canvas.parentWin = mainwindow debugString = QString("Finished Loading Canvas...") self.mainwindow.statusbar.showMessage(debugString) # lay our widgets out in the main window self.layout = QVBoxLayout(self.mainwindow.widgetMap) self.layout.addWidget(self.canvas) # Link in the map tools QObject.connect(self.mainwindow.mpActionZoomIn, SIGNAL("triggered()"), self.zoomIn) QObject.connect(self.mainwindow.mpActionZoomOut, SIGNAL("triggered()"), self.zoomOut) QObject.connect(self.mainwindow.mpActionPan, SIGNAL("triggered()"), self.pan) # Map tools self.toolPan = QgsMapToolPan(self.canvas) self.toolPan.setAction(self.mainwindow.mpActionPan) self.toolZoomIn = QgsMapToolZoom(self.canvas, False) self.toolZoomIn.setAction(self.mainwindow.mpActionZoomIn) self.toolZoomOut = QgsMapToolZoom(self.canvas, True) self.toolZoomOut.setAction(self.mainwindow.mpActionZoomOut) ##### Lets test out a simple map self.layers = [] f = "data/st99_d00.shp" f_string = QString(f) info = QFileInfo(QString(f)) # create layer layer = QgsVectorLayer(QString(f), info.completeBaseName(), "ogr") if not layer.isValid(): # Deal with the error debugString = QString("Error Loading Layer...") self.mainwindow.statusbar.showMessage(debugString) return QgsMapLayerRegistry.instance().addMapLayer(layer) # set extent to the extent of our layer self.canvas.setExtent(layer.extent()) # Set the transparency for the layer #layer.setTransparency(190) # set the map canvas layer set cl = QgsMapCanvasLayer(layer) self.layers.insert(0,cl) self.canvas.setLayerSet(self.layers)
def testPrintMapFromTemplate(self): """Test that we can get a map to render in the template.""" myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif') myFileInfo = QFileInfo(myPath) myRasterLayer = QgsRasterLayer(myFileInfo.filePath(), myFileInfo.completeBaseName()) myRenderer = QgsMultiBandColorRenderer( myRasterLayer.dataProvider(), 2, 3, 4 ) #mRasterLayer.setRenderer( rasterRenderer ) myPipe = myRasterLayer.pipe() assert myPipe.set( myRenderer ), "Cannot set pipe renderer" QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer]) myMapRenderer = QgsMapRenderer() myLayerStringList = [] myLayerStringList.append(myRasterLayer.id()) myMapRenderer.setLayerSet(myLayerStringList) myMapRenderer.setProjectionsEnabled(False) myComposition = QgsComposition(myMapRenderer) myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt') myTemplateFile = file(myFile, 'rt') myTemplateContent = myTemplateFile.read() myTemplateFile.close() myDocument = QDomDocument() myDocument.setContent(myTemplateContent) myComposition.loadFromTemplate(myDocument) # now render the map, first zooming to the raster extents myMap = myComposition.getComposerMapById(0) myMessage = ('Map 0 could not be found in template %s', myFile) assert myMap is not None, myMessage myExtent = myRasterLayer.extent() myMap.setNewExtent(myExtent) myImagePath = os.path.join(str(QDir.tempPath()), 'template_map_render_python.png') myPageNumber = 0 myImage = myComposition.printPageAsRaster(myPageNumber) myImage.save(myImagePath) assert os.path.exists(myImagePath), 'Map render was not created.' # Not sure if this is a predictable way to test but its quicker than # rendering. myFileSize = QFileInfo(myImagePath).size() myExpectedFileSize = 100000 myMessage = ('Expected file size to be greater than %s, got %s' ' for %s' % (myExpectedFileSize, myFileSize, myImagePath)) assert myFileSize > myExpectedFileSize, myMessage
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 saveTemplate(self): """ Creates and saves a new document template. """ #Validate if the user has specified the data source if self.selectedDataSource() == "": QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), \ QApplication.translate("ComposerWrapper","Please specify the " \ "data source name for the document composition.")) return #If it is a new unsaved document template then prompt for the document name. docFile = self.documentFile() if docFile == None: docName,ok = QInputDialog.getText(self.composerView(), \ QApplication.translate("ComposerWrapper","Template Name"), \ QApplication.translate("ComposerWrapper","Please enter the template name below"), \ ) if ok and docName != "": templateDir = self._composerTemplatesPath() if templateDir == None: QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), \ QApplication.translate("ComposerWrapper","Directory for document templates could not be found.")) return absPath = templateDir + "/" + docName + ".sdt" docFile = QFile(absPath) else: return docFileInfo = QFileInfo(docFile) if not docFile.open(QIODevice.WriteOnly): QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Operation Error"), \ "{0}\n{1}".format(QApplication.translate("ComposerWrapper","Could not save template file."), \ docFile.errorString() )) return templateDoc = QDomDocument() self._writeXML(templateDoc, docFileInfo.completeBaseName()) if docFile.write(templateDoc.toByteArray()) == -1: QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Error"), \ QApplication.translate("ComposerWrapper","Could not save template file.")) return docFile.close() self.setDocumentFile(docFile)
def saveTemplate(self): """ Creates and saves a new document template. """ #Validate if the user has specified the data source if self.selectedDataSource() == "": QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), \ QApplication.translate("ComposerWrapper","Please specify the " \ "data source name for the document composition.")) return #If it is a new unsaved document template then prompt for the document name. docFile = self.documentFile() if docFile == None: docName,ok = QInputDialog.getText(self.composerView(), \ QApplication.translate("ComposerWrapper","Template Name"), \ QApplication.translate("ComposerWrapper","Please enter the template name below"), \ ) if ok and docName != "": templateDir = self._composerTemplatesPath() if templateDir == None: QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), \ QApplication.translate("ComposerWrapper","Directory for document templates could not be found.")) return absPath = templateDir + "/" + docName + ".sdt" docFile= QFile(absPath) else: return docFileInfo = QFileInfo(docFile) if not docFile.open(QIODevice.WriteOnly): QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Operation Error"), \ "{0}\n{1}".format(QApplication.translate("ComposerWrapper","Could not save template file."), \ docFile.errorString() )) return templateDoc = QDomDocument() self._writeXML(templateDoc,docFileInfo.completeBaseName()) if docFile.write(templateDoc.toByteArray()) == -1: QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Error"), \ QApplication.translate("ComposerWrapper","Could not save template file.")) return docFile.close() self.setDocumentFile(docFile)
def on_pbn_set_storage_location_released(self): start_dir = paths.OPUS_PROJECT_CONFIGS_PATH configDialog = QFileDialog() filter_str = QString("*.gdb") fd = configDialog.getExistingDirectory(self, QString("Please select an ESRI geodatabase (*.gdb)..."), #, *.sde, *.mdb)..."), QString(start_dir), QFileDialog.ShowDirsOnly) if len(fd) != 0: fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameBaseName = fileNameInfo.completeBaseName() self.leOption1.setText(fileName)
def on_pbn_set_storage_location_released(self): start_dir = os.path.join(os.environ['OPUS_HOME'], 'project_configs') configDialog = QFileDialog() filter_str = QString("*.gdb") fd = configDialog.getExistingDirectory(self, QString("Please select an ESRI geodatabase (*.gdb)..."), #, *.sde, *.mdb)..."), QString(start_dir), QFileDialog.ShowDirsOnly) if len(fd) != 0: fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameBaseName = fileNameInfo.completeBaseName() self.leOption1.setText(fileName)
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 _create_perimeter_layer(self, layer, perimeterLayerFilePath, categoryName, perimeterLayerName, loadedLayer): """Creates a perimeter layer from the given layer. Args: layer (QgsVectorLayer): A reference to the layer. perimeterLayerFilePath (str): A full path to the perimeter layer. categoryName (str): A name of the category field the layer is about to be dissolved by. perimeterLayerName (str): A name of the perimeter layer. loadedLayer (bool): A reference to the loaded layer. This is relevant only for Windows platform. Returns: QgsVectorLayer: A reference to the perimeter layer. """ fileInfo = QFileInfo(perimeterLayerFilePath) tempPerimeterLayerName = fileInfo.completeBaseName() + u'.temp' layer.removeSelection() tempPerimeterLayerPath = processing.runalg('qgis:dissolve', layer, False, categoryName, None)['OUTPUT'] tempPerimeterLayer = QgsVectorLayer(tempPerimeterLayerPath, tempPerimeterLayerName, 'ogr') if loadedLayer: perimeterLayerName = loadedLayer.name() QgsMapLayerRegistry.instance().removeMapLayer(loadedLayer) QgsApplication.processEvents() processing.runalg('qgis:multiparttosingleparts', tempPerimeterLayer, perimeterLayerFilePath) perimeterLayer = QgsVectorLayer(perimeterLayerFilePath, perimeterLayerName, 'ogr') QgsMapLayerRegistry.instance().addMapLayer(perimeterLayer) expression = QgsExpression("\"{}\" is null".format( self.shortCategoryName)) self.dW.delete_features_by_expression(perimeterLayer, expression) return perimeterLayer
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 on_pbn_set_esri_storage_location_released(self): print 'pbn_set_esri_storage_location released' from opus_core.misc import directory_path_from_opus_path start_dir = directory_path_from_opus_path('opus_gui.projects') configDialog = QFileDialog() filter_str = QString("*.gdb") fd = configDialog.getExistingDirectory(self,QString("Please select an ESRI geodatabase (*.gdb)..."), #, *.sde, *.mdb)..."), QString(start_dir), QFileDialog.ShowDirsOnly) if len(fd) != 0: fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameBaseName = fileNameInfo.completeBaseName() self.le_esri_storage_location.setText(fileName)
def on_pbn_set_storage_location_released(self): start_dir = os.path.join(os.environ['OPUS_HOME'], 'project_configs') configDialog = QFileDialog() filter_str = QString("*.gdb") fd = configDialog.getExistingDirectory( self, QString("Please select an ESRI geodatabase (*.gdb)..." ), #, *.sde, *.mdb)..."), QString(start_dir), QFileDialog.ShowDirsOnly) if len(fd) != 0: fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameBaseName = fileNameInfo.completeBaseName() self.leOption1.setText(fileName)
def on_pbn_set_storage_location_released(self): start_dir = paths.OPUS_PROJECT_CONFIGS_PATH configDialog = QFileDialog() filter_str = QString("*.gdb") fd = configDialog.getExistingDirectory( self, QString("Please select an ESRI geodatabase (*.gdb)..." ), #, *.sde, *.mdb)..."), QString(start_dir), QFileDialog.ShowDirsOnly) if len(fd) != 0: fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameBaseName = fileNameInfo.completeBaseName() self.leOption1.setText(fileName)
def action_writeGCode_triggered(self): if not len(self.trafoPoints) in {3, 4}: QMessageBox.warning(self, "not enough points", "Please select at least 3 transformation points.") return T=bilinearTrafo(self.trafoPoints, self.trafoMachinePoints) paths={} for dia in self.fitHoles: toolNr=self.drills[dia] paths[toolNr]=findPath(T.transform(self.fitHoles[dia])) fi=QFileInfo(self.currentFile) filename=fi.absolutePath() + "/" + fi.completeBaseName() + ".ngc" writeGCode(paths, filename, self.feedrate, self.drillDepth, self.drillSpacing) QMessageBox.information(self, "G-Code", "Finished!")
def on_pbn_set_esri_storage_location_released(self): print 'pbn_set_esri_storage_location released' from opus_core.misc import directory_path_from_opus_path start_dir = directory_path_from_opus_path('opus_gui.projects') configDialog = QFileDialog() filter_str = QString("*.gdb") fd = configDialog.getExistingDirectory( self, QString("Please select an ESRI geodatabase (*.gdb)..." ), #, *.sde, *.mdb)..."), QString(start_dir), QFileDialog.ShowDirsOnly) if len(fd) != 0: fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameBaseName = fileNameInfo.completeBaseName() self.le_esri_storage_location.setText(fileName)
def zipLayer(layer): """Compress layer to zip file""" file_path = layer.dataProvider().dataSourceUri() if file_path.find('|') != -1: file_path = file_path[0:file_path.find('|')] if file_path.startswith('/vsizip/'): file_path = file_path.replace('/vsizip/', '') if layer.storageType() in [ 'ESRI Shapefile', 'GPX', 'GeoJSON', 'LIBKML' ]: return file_path _file = QFile(file_path) file_info = QFileInfo(_file) dirname = file_info.dir().absolutePath() filename = stripAccents(file_info.completeBaseName()) layername = stripAccents(layer.name()) tempdir = checkTempDir() zip_path = os.path.join(tempdir, layername + '.zip') zip_file = zipfile.ZipFile(zip_path, 'w') if layer.storageType() == 'ESRI Shapefile': for suffix in ['.shp', '.dbf', '.prj', '.shx']: if os.path.exists(os.path.join(dirname, filename + suffix)): zip_file.write(os.path.join(dirname, filename + suffix), layername + suffix, zipfile.ZIP_DEFLATED) elif layer.storageType() == 'GeoJSON': zip_file.write(file_path, layername + '.geojson', zipfile.ZIP_DEFLATED) elif layer.storageType() == 'GPX': zip_file.write(file_path, layername + '.gpx', zipfile.ZIP_DEFLATED) elif layer.storageType() == 'LIBKML': zip_file.write(file_path, layername + '.kml', zipfile.ZIP_DEFLATED) else: geo_json_name = os.path.join(tempfile.tempdir, layername) error = QgsVectorFileWriter.writeAsVectorFormat( layer, geo_json_name, "utf-8", None, "GeoJSON") if error == QgsVectorFileWriter.NoError: zip_file.write(geo_json_name + '.geojson', layername + '.geojson', zipfile.ZIP_DEFLATED) zip_file.close() return zip_path
def getSize(self, layer): filePath = layer.dataProvider().dataSourceUri() if filePath.find('|') != -1: filePath = filePath[0:filePath.find('|')] file = QFile(filePath) fileInfo = QFileInfo(file) dirName = fileInfo.dir().absolutePath() fileName = fileInfo.completeBaseName() size = 0 if layer.storageType() == 'ESRI Shapefile': for suffix in ['.shp', '.dbf', '.prj', '.shx']: file = QFile(os.path.join(dirName, fileName + suffix)) fileInfo = QFileInfo(file) size = size + fileInfo.size() return size
def _create_spatialite_db_file(self, dbPath): """Creates a SpatiaLite database file. Args: dbPath (str): A full path to the database. Returns: dbPath (str): A full path to the SpatiaLite database. """ dbInfo = QFileInfo(dbPath) sdbPath = QDir(dbInfo.absolutePath())\ .filePath(dbInfo.completeBaseName() + '.sdb') sdbInfo = QFileInfo(sdbPath) if not sdbInfo.isFile(): self.set_text_statusbar.emit( u'Importuji data do SpatiaLite databáze...', 0, False) QgsApplication.processEvents() sqliteDriver = ogr.GetDriverByName('SQLite') spatialiteDataSource = sqliteDriver.CreateDataSource( sdbPath, ['SPATIALITE=YES']) sqliteDataSource = ogr.Open(dbPath) for layerCode in ( self.dW.parLayerCode, ) + self.dW.vertexLayerCodes: originalLayer = sqliteDataSource.GetLayerByName(layerCode) copiedLayer = spatialiteDataSource.CopyLayer( originalLayer, layerCode, ['LAUNDER=NO']) sqliteDataSource.Destroy() spatialiteDataSource.Destroy() QgsApplication.processEvents() return sdbPath
def zipLayer(self, layer): filePath = layer.dataProvider().dataSourceUri() if filePath.find('|') != -1: filePath = filePath[0:filePath.find('|')] file = QFile(filePath) fileInfo = QFileInfo(file) dirName = fileInfo.dir().absolutePath() fileName = fileInfo.completeBaseName() tempdir = tempfile.tempdir if tempdir is None: tempdir = tempfile.mkdtemp() zipPath = os.path.join(tempdir, layer.name() + '.zip') zipFile = zipfile.ZipFile(zipPath, 'w') if layer.storageType() == 'ESRI Shapefile': for suffix in ['.shp', '.dbf', '.prj', '.shx']: if os.path.exists(os.path.join(dirName, fileName + suffix)): zipFile.write(os.path.join(dirName, fileName + suffix), fileName + suffix, zipfile.ZIP_DEFLATED) elif layer.storageType() == 'GeoJSON': zipFile.write(filePath, layer.name() + '.geojson', zipfile.ZIP_DEFLATED) else: geoJsonName = os.path.join(tempfile.tempdir, layer.name()) error = QgsVectorFileWriter.writeAsVectorFormat( layer, geoJsonName, "utf-8", None, "GeoJSON") if error == QgsVectorFileWriter.NoError: zipFile.write(geoJsonName + '.geojson', layer.name() + '.geojson', zipfile.ZIP_DEFLATED) ''' elif layer.storageType() == 'LIBKML': kmlName = os.path.join(tempfile.tempdir, layer.name()) error = QgsVectorFileWriter.writeAsVectorFormat(layer, kmlName, "utf-8", None, "GeoJSON") if error == QgsVectorFileWriter.NoError: zipFile.write(kmlName + '.geojson', layer.name() + '.geojson', zipfile.ZIP_DEFLATED) ''' zipFile.close() return zipPath
def getSize(self, layer): filePath = layer.dataProvider().dataSourceUri() if filePath.find('|') != -1: filePath = filePath[0:filePath.find('|')] file = QFile(filePath) fileInfo = QFileInfo(file) dirName = fileInfo.dir().absolutePath() fileName = fileInfo.completeBaseName() size = 0 if layer.storageType() == 'ESRI Shapefile': for suffix in ['.shp', '.dbf', '.prj', '.shx']: file = QFile(os.path.join(dirName, fileName + suffix)) fileInfo = QFileInfo(file) size = size + fileInfo.size() elif layer.storageType() in ['GPX', 'GeoJSON', 'LIBKML']: size = size + fileInfo.size() return size
def open_file_dialog(self, title, filters, existence): """Opens a file dialog. Args: title (str): A title of the file dialog. filters (str): Available filter(s) of the file dialog. existence (bool): True when the file has to exist (QFileDialog.getOpenFileNameAndFilter). False when the file does not have to exist (QFileDialog.getSaveFileNameAndFilter). Returns: str: A path to the selected file. """ sender = self.sender().objectName() lastUsedFilePath = self._get_settings(sender + '-' + 'lastUsedFilePath') lastUsedFilter = self._get_settings(sender + '-' + 'lastUsedFilter') if existence: filePath, usedFilter = QFileDialog.getOpenFileNameAndFilter( self, title, lastUsedFilePath, filters, lastUsedFilter) else: filePath, usedFilter = QFileDialog.getSaveFileNameAndFilter( self, title, lastUsedFilePath, filters, lastUsedFilter) fileInfo = QFileInfo(filePath) if platform.system() == u'Linux' and fileInfo.suffix() != u'shp': filePath = QDir(fileInfo.absolutePath())\ .filePath(fileInfo.completeBaseName() + u'.shp') if filePath and usedFilter: self._set_settings(sender + '-' + 'lastUsedFilePath', filePath) self._set_settings(sender + '-' + 'lastUsedFilter', usedFilter) return filePath
def zipLayer(layer): """Compress layer to zip file""" file_path = layer.dataProvider().dataSourceUri() if file_path.find('|') != -1: file_path = file_path[0:file_path.find('|')] if file_path.startswith('/vsizip/'): file_path = file_path.replace('/vsizip/', '') if layer.storageType() in ['ESRI Shapefile', 'GPX', 'GeoJSON', 'LIBKML']: return file_path _file = QFile(file_path) file_info = QFileInfo(_file) dirname = file_info.dir().absolutePath() filename = file_info.completeBaseName() tempdir = checkTempDir() zip_path = os.path.join(tempdir, layer.name() + '.zip') zip_file = zipfile.ZipFile(zip_path, 'w') if layer.storageType() == 'ESRI Shapefile': for suffix in ['.shp', '.dbf', '.prj', '.shx']: if os.path.exists(os.path.join(dirname, filename + suffix)): zip_file.write(os.path.join(dirname, filename + suffix), layer.name() + suffix, zipfile.ZIP_DEFLATED) elif layer.storageType() == 'GeoJSON': zip_file.write(file_path, layer.name() + '.geojson', zipfile.ZIP_DEFLATED) elif layer.storageType() == 'GPX': zip_file.write(file_path, layer.name() + '.gpx', zipfile.ZIP_DEFLATED) elif layer.storageType() == 'LIBKML': zip_file.write(file_path, layer.name() + '.kml', zipfile.ZIP_DEFLATED) else: geo_json_name = os.path.join(tempfile.tempdir, layer.name()) error = QgsVectorFileWriter.writeAsVectorFormat(layer, geo_json_name, "utf-8", None, "GeoJSON") if error == QgsVectorFileWriter.NoError: zip_file.write(geo_json_name + '.geojson', layer.name() + '.geojson', zipfile.ZIP_DEFLATED) zip_file.close() return zip_path
def zipLayer(self, layer): filePath = layer.dataProvider().dataSourceUri() if filePath.find('|') != -1: filePath = filePath[0:filePath.find('|')] file = QFile(filePath) fileInfo = QFileInfo(file) dirName = fileInfo.dir().absolutePath() fileName = fileInfo.completeBaseName() tempdir = tempfile.tempdir if tempdir is None: tempdir = tempfile.mkdtemp() zipPath = os.path.join(tempdir, layer.name() + '.zip') zipFile = zipfile.ZipFile(zipPath, 'w') if layer.storageType() == 'ESRI Shapefile': for suffix in ['.shp', '.dbf', '.prj', '.shx']: if os.path.exists(os.path.join(dirName, fileName + suffix)): zipFile.write(os.path.join(dirName, fileName + suffix), fileName + suffix, zipfile.ZIP_DEFLATED) elif layer.storageType() == 'GeoJSON': zipFile.write(filePath, layer.name() + '.geojson', zipfile.ZIP_DEFLATED) else: geoJsonName = os.path.join(tempfile.tempdir, layer.name()) error = QgsVectorFileWriter.writeAsVectorFormat(layer, geoJsonName, "utf-8", None, "GeoJSON") if error == QgsVectorFileWriter.NoError: zipFile.write(geoJsonName + '.geojson', layer.name() + '.geojson', zipfile.ZIP_DEFLATED) ''' elif layer.storageType() == 'LIBKML': kmlName = os.path.join(tempfile.tempdir, layer.name()) error = QgsVectorFileWriter.writeAsVectorFormat(layer, kmlName, "utf-8", None, "GeoJSON") if error == QgsVectorFileWriter.NoError: zipFile.write(kmlName + '.geojson', layer.name() + '.geojson', zipfile.ZIP_DEFLATED) ''' zipFile.close() return zipPath
def zipLayer(self, layer): filePath = layer.dataProvider().dataSourceUri() if filePath.find('|') != -1: filePath = filePath[0:filePath.find('|')] file = QFile(filePath) fileInfo = QFileInfo(file) dirName = fileInfo.dir().absolutePath() fileName = fileInfo.completeBaseName() zipPath = os.path.join(tempfile.tempdir, layer.name() + '.zip') zipFile = zipfile.ZipFile(zipPath, 'w') if os.path.exists(os.path.join(dirName, fileName + '.shp')): zipFile.write(os.path.join(dirName, fileName + '.shp'), fileName + '.shp', zipfile.ZIP_DEFLATED) if os.path.exists(os.path.join(dirName, fileName + '.dbf')): zipFile.write(os.path.join(dirName, fileName + '.dbf'), fileName + '.dbf', zipfile.ZIP_DEFLATED) if os.path.exists(os.path.join(dirName, fileName + '.prj')): zipFile.write(os.path.join(dirName, fileName + '.prj'), fileName + '.prj', zipfile.ZIP_DEFLATED) if os.path.exists(os.path.join(dirName, fileName + '.shx')): zipFile.write(os.path.join(dirName, fileName + '.shx'), fileName + '.shx', zipfile.ZIP_DEFLATED) zipFile.close() return zipPath
def testCase(self): TEST_DATA_DIR = unitTestDataPath() vectorFileInfo = QFileInfo( TEST_DATA_DIR + "/france_parts.shp") mVectorLayer = QgsVectorLayer( vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr" ) QgsMapLayerRegistry.instance().addMapLayers( [mVectorLayer] ) # create composition with composer map mMapRenderer = QgsMapRenderer() layerStringList = [] layerStringList.append( mVectorLayer.id() ) mMapRenderer.setLayerSet( layerStringList ) mMapRenderer.setProjectionsEnabled( False ) mComposition = QgsComposition( mMapRenderer ) mComposition.setPaperSize( 297, 210 ) mLabel = QgsComposerLabel( mComposition ) mComposition.addComposerLabel( mLabel ) self.evaluation_test( mComposition, mLabel ) self.feature_evaluation_test( mComposition, mLabel, mVectorLayer ) self.page_evaluation_test( mComposition, mLabel, mVectorLayer )
def testCase(self): self.TEST_DATA_DIR = unitTestDataPath() vectorFileInfo = QFileInfo( self.TEST_DATA_DIR + "/france_parts.shp") mVectorLayer = QgsVectorLayer( vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr" ) QgsMapLayerRegistry.instance().addMapLayers( [mVectorLayer] ) # create composition with composer map mMapRenderer = QgsMapRenderer() layerStringList = [] layerStringList.append( mVectorLayer.id() ) mMapRenderer.setLayerSet( layerStringList ) mMapRenderer.setProjectionsEnabled( True ) mMapRenderer.setMapUnits( QGis.Meters ) # select epsg:2154 crs = QgsCoordinateReferenceSystem() crs.createFromSrid( 2154 ) mMapRenderer.setDestinationCrs( crs ) self.mComposition = QgsComposition( mMapRenderer ) self.mComposition.setPaperSize( 297, 210 ) # fix the renderer, fill with green props = { "color": "0,127,0" } fillSymbol = QgsFillSymbolV2.createSimple( props ) renderer = QgsSingleSymbolRendererV2( fillSymbol ) mVectorLayer.setRendererV2( renderer ) # the atlas map self.mAtlasMap = QgsComposerMap( self.mComposition, 20, 20, 130, 130 ) self.mAtlasMap.setFrameEnabled( True ) self.mComposition.addComposerMap( self.mAtlasMap ) # the atlas self.mAtlas = self.mComposition.atlasComposition() self.mAtlas.setCoverageLayer( mVectorLayer ) self.mAtlas.setEnabled( True ) self.mComposition.setAtlasMode( QgsComposition.ExportAtlas ) # an overview mOverview = QgsComposerMap( self.mComposition, 180, 20, 50, 50 ) mOverview.setFrameEnabled( True ) mOverview.setOverviewFrameMap( self.mAtlasMap.id() ) self.mComposition.addComposerMap( mOverview ) nextent = QgsRectangle( 49670.718, 6415139.086, 699672.519, 7065140.887 ) mOverview.setNewExtent( nextent ) # set the fill symbol of the overview map props2 = { "color": "127,0,0,127" } fillSymbol2 = QgsFillSymbolV2.createSimple( props2 ) mOverview.setOverviewFrameMapSymbol( fillSymbol2 ) # header label self.mLabel1 = QgsComposerLabel( self.mComposition ) self.mComposition.addComposerLabel( self.mLabel1 ) self.mLabel1.setText( "[% \"NAME_1\" %] area" ) self.mLabel1.setFont( QgsFontUtils.getStandardTestFont() ) self.mLabel1.adjustSizeToText() self.mLabel1.setSceneRect( QRectF( 150, 5, 60, 15 ) ) qWarning( "header label font: %s exactMatch:%s" % ( self.mLabel1.font().toString(), self.mLabel1.font().exactMatch() ) ) # feature number label self.mLabel2 = QgsComposerLabel( self.mComposition ) self.mComposition.addComposerLabel( self.mLabel2 ) self.mLabel2.setText( "# [%$feature || ' / ' || $numfeatures%]" ) self.mLabel2.setFont( QgsFontUtils.getStandardTestFont() ) self.mLabel2.adjustSizeToText() self.mLabel2.setSceneRect( QRectF( 150, 200, 60, 15 ) ) qWarning( "feature number label font: %s exactMatch:%s" % ( self.mLabel2.font().toString(), self.mLabel2.font().exactMatch() ) ) self.filename_test() self.autoscale_render_test() self.autoscale_render_test_old_api() self.fixedscale_render_test() self.predefinedscales_render_test() self.hidden_render_test()
def importXMLFromFile(self): """ NO DOCUMENTATION """ assert self.has_selected_item() # print "importXMLFromFile" # First, prompt the user for the filename to read in start_dir = "" opus_home = os.environ.get("OPUS_HOME") if opus_home: start_dir_test = os.path.join(opus_home, "project_configs") if start_dir_test: start_dir = start_dir_test configDialog = QFileDialog() filter_str = QString("*.xml") fd = configDialog.getOpenFileName( self.manager.base_widget, "Please select an xml file to import...", start_dir, filter_str ) # Check for cancel if len(fd) == 0: return fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameInfoBaseName = fileNameInfo.completeBaseName() fileNameInfoName = fileNameInfo.fileName().trimmed() fileNameInfoPath = fileNameInfo.absolutePath().trimmed() # Pass that in to create a new XMLConfiguration xml_config = XMLConfiguration(str(fileNameInfoName), str(fileNameInfoPath)) xml_node = xml_config.full_tree.getroot() if len(xml_node) == 0: raise ValueError("Loading node from XML file failed. " "No node definition found") xml_node = xml_node[0] parent_node = self.selected_item().node allowed_parent_tags = { "tool": ["tool_group"], "class_module": ["tool"], "path_to_tool_modules": ["tool_library"], "tool_library": ["data_manager"], "tool_group": ["tool_library"], "params": ["tool"], "param": ["params"], "tool_config": ["tool_set"], "tool_set": ["tool_sets"], "tool_sets": ["data_manager"], } if parent_node.tag not in allowed_parent_tags[xml_node.tag]: MessageBox.error( mainwindow=self.view, text="Invalid Xml insert", detailed_text=( 'Xml insert of node of type "%s" failed. ' 'Invalid type of parent node is "%s" - needs to be one of %s' % (xml_node.tag, parent_node.tag, str(allowed_parent_tags[xml_node.tag])) ), ) return # Insert it into the parent node from where the user clicked name = xml_node.get("name") if xml_node.get("name") is not None else "" if self.model.insertRow(0, self.selected_index(), xml_node) is False: MessageBox.error( mainwindow=self.view, text="Xml Insert Failed", detailed_text=( 'Xml insert of node with name "%s" failed - ' "most likely because there is already a node with that name." % name ), ) return
def saveTemplate(self): """ Creates and saves a new document template. """ #Validate if the user has specified the data source if not self.selectedDataSource(): QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), QApplication.translate("ComposerWrapper","Please specify the " "data source name for the document composition.")) return #If it is a new unsaved document template then prompt for the document name. docFile = self.documentFile() if docFile is None: docName,ok = QInputDialog.getText(self.composerView(), QApplication.translate("ComposerWrapper","Template Name"), QApplication.translate("ComposerWrapper","Please enter the template name below"), ) if ok and docName: templateDir = self._composerTemplatesPath() if templateDir is None: QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Error"), QApplication.translate("ComposerWrapper", "Directory for document templates cannot not be found.")) return absPath = templateDir + "/" + docName + ".sdt" #Check if there is an existing document with the same name caseInsenDic = CaseInsensitiveDict(documentTemplates()) if docName in caseInsenDic: result = QMessageBox.warning(self.composerView(), QApplication.translate("ComposerWrapper", "Existing Template"), u"'{0}' {1}.\nDo you want to replace the " "existing template?".format(docName, QApplication.translate("ComposerWrapper", "already exists")), QMessageBox.Yes|QMessageBox.No) if result == QMessageBox.Yes: #Delete the existing template delFile = QFile(absPath) remStatus = delFile.remove() if not remStatus: QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper", "Delete Error"), "'{0}' {1}.".format(docName, QApplication.translate("ComposerWrapper", "template could not be removed by the system," " please remove it manually from the document templates directory."))) return else: return docFile= QFile(absPath) else: return docFileInfo = QFileInfo(docFile) if not docFile.open(QIODevice.WriteOnly): QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper", "Save Operation Error"), "{0}\n{1}".format(QApplication.translate("ComposerWrapper", "Could not save template file."), docFile.errorString() )) return templateDoc = QDomDocument() template_name = docFileInfo.completeBaseName() self._writeXML(templateDoc, template_name) if docFile.write(templateDoc.toByteArray()) == -1: QMessageBox.critical(self.composerView(), QApplication.translate("ComposerWrapper","Save Error"), QApplication.translate("ComposerWrapper","Could not save template file.")) return else: self.mainWindow().setWindowTitle(template_name) docFile.close()
''' QGIS Processing script (c) 2017 Andreas Plesch save style in qml file ''' ##X3D=group ##save_raster_style=name ##input_raster=raster ##style_file=output file import shutil from PyQt4.QtCore import QFile, QFileInfo, QDir #saveNamedStyle always writes to .qml fileInfo = QFileInfo(style_file) style_file = fileInfo.path() + QDir.separator() + fileInfo.completeBaseName() + ".qml" file=QFile(style_file) #touch, create since saveStyle only writes file if it exists file.open(QFile.ReadWrite) file.close() r = processing.getObject(input_raster) print(r.saveNamedStyle(style_file)) #saveNamedStyle always writes to .qml #copy back #fileInfo = QFileInfo(style_file) #style_file = fileInfo.path() + QDir.separator() + fileInfo.completeBaseName() + ".qml" #shutil.copy(qml, style_file)
def upload_document(self, path, doc_type='', doc_type_code='', use_temp_dir=True, clear_all=True): """ Uploads the document specified in path to the folder of the given document type based on the specified document type folder mapping. :param path: Absolute path of the file to be uploaded. :type path: str :param doc_type: Name of the document type. :type doc_type: str :param doc_type_code: Code of the document type which is used to identify the document type. If doc_type has already been specified then the value of this parameter is skipped. :type doc_type_code: str :param use_temp_dir: Specify True to upload the document in the Temp directory using an auto-generated name then move it to the correct document type repository using the :func:'persist_documents' method. If set to False, the document will be directly uploaded to the corresponding document type folder. Default is True. :type use_temp_dir: bool :param clear_all: True to clear all previously uploaded documents (in the current session) for the given document type. :return: Returns the AtomPub document object, else None if it was not successfully created. :rtype: cmislib.domain.Document """ if not doc_type and not doc_type_code: msg = 'Please specify the document type name or code.' raise CmisDocumentMapperException(msg) if not self._cmis_mgr: msg = 'CmisManager object not specified.' raise CmisDocumentMapperException(msg) # Get doc_type from code if doc_type_code and not doc_type_code: # @gkahiu code underneath may never be reached doc_type_m = self.mapping_by_code(doc_type_code) if not doc_type_m: msg = u'Document type could not be retrieved from {0} ' \ u'document type code.'.format(doc_type_code) raise CmisDocumentMapperException(msg) else: doc_type = doc_type_m.doc_type if not doc_type in self._doc_type_mapping: msg = 'Mapping for the specified document type name not found.' raise CmisDocumentMapperException(msg) if use_temp_dir: dest_folder = self._cmis_mgr.context_temp_folder else: dest_folder = self.document_type_folder(doc_type) # Try create the folder if it does not exist if not dest_folder: if use_temp_dir: status = self._cmis_mgr.create_temp_folder() if not status: msg = 'Temp directory could not be created.' raise CmisDocumentMapperException(msg) else: dest_folder = self._cmis_mgr.context_temp_folder else: dest_folder = self.create_document_type_folder(doc_type) # Clear all documents of the given type, if option has been specified if clear_all: self.remove_all_documents(doc_type) if use_temp_dir: doc_name = str(uuid4()) else: # Get name of the file without the extension fi = QFileInfo(path) doc_name = fi.completeBaseName() # Determine whether file is text or binary read_mode = 'rb' mime_type, encoding = guess_type(path) text_idx = mime_type.find('text') if text_idx != -1: read_mode = 'r' if not mime_type: msg = 'MIME type could not be determined.' raise CmisDocumentMapperException(msg) # Manually set the valid MIME type for PDF if mime_type == 'pdf': mime_type = 'application/pdf' cmis_doc = None with open(path, read_mode) as f: cmis_doc = dest_folder.createDocument(doc_name, contentFile=f, contentType=mime_type) # Update reference of uploaded documents. if not doc_type in self._uploaded_docs: self._uploaded_docs[doc_type] = [] if cmis_doc: doc_info = UploadedDocInfo(cmis_doc=cmis_doc, temp_dir=use_temp_dir) uploaded_type_docs = self._uploaded_docs[doc_type] uploaded_type_docs.append(doc_info) return cmis_doc
def saveTemplate(self): """ Creates and saves a new document template. """ # Validate if the user has specified the data source if not self.selectedDataSource(): QMessageBox.critical( self.composerView(), QApplication.translate("ComposerWrapper", "Error"), QApplication.translate( "ComposerWrapper", "Please specify the " "data source name for the document composition.")) return # Assert if the referenced table name has been set if not self.selected_referenced_table(): QMessageBox.critical( self.composerView(), QApplication.translate("ComposerWrapper", "Error"), QApplication.translate( "ComposerWrapper", "Please specify the " "referenced table name for the selected data source.")) return # If it is a new unsaved document template then prompt for the document name. docFile = self.documentFile() if docFile is None: docName, ok = QInputDialog.getText( self.composerView(), QApplication.translate("ComposerWrapper", "Template Name"), QApplication.translate("ComposerWrapper", "Please enter the template name below"), ) if not ok: return if ok and not docName: QMessageBox.critical( self.composerView(), QApplication.translate("ComposerWrapper", "Error"), QApplication.translate("ComposerWrapper", "Please enter a template name!")) self.saveTemplate() if ok and docName: templateDir = self._composerTemplatesPath() if templateDir is None: QMessageBox.critical( self.composerView(), QApplication.translate("ComposerWrapper", "Error"), QApplication.translate( "ComposerWrapper", "Directory for document templates cannot not be found." )) return absPath = templateDir + "/" + docName + ".sdt" #Check if there is an existing document with the same name caseInsenDic = CaseInsensitiveDict(documentTemplates()) if docName in caseInsenDic: result = QMessageBox.warning( self.composerView(), QApplication.translate("ComposerWrapper", "Existing Template"), u"'{0}' {1}.\nDo you want to replace the " "existing template?".format( docName, QApplication.translate("ComposerWrapper", "already exists")), QMessageBox.Yes | QMessageBox.No) if result == QMessageBox.Yes: #Delete the existing template delFile = QFile(absPath) remStatus = delFile.remove() if not remStatus: QMessageBox.critical( self.composerView(), QApplication.translate("ComposerWrapper", "Delete Error"), "'{0}' {1}.".format( docName, QApplication.translate( "ComposerWrapper", "template could not be removed by the system," " please remove it manually from the document templates directory." ))) return else: return docFile = QFile(absPath) else: return docFileInfo = QFileInfo(docFile) if not docFile.open(QIODevice.WriteOnly): QMessageBox.critical( self.composerView(), QApplication.translate("ComposerWrapper", "Save Operation Error"), "{0}\n{1}".format( QApplication.translate("ComposerWrapper", "Could not save template file."), docFile.errorString())) return templateDoc = QDomDocument() template_name = docFileInfo.completeBaseName() # Catch exception raised when writing items' elements try: self._writeXML(templateDoc, template_name) except Exception as exc: msg = unicode(exc) QMessageBox.critical( self.composerView(), QApplication.translate("ComposerWrapper", "Save Error"), msg) docFile.close() docFile.remove() return if docFile.write(templateDoc.toByteArray()) == -1: QMessageBox.critical( self.composerView(), QApplication.translate("ComposerWrapper", "Save Error"), QApplication.translate("ComposerWrapper", "Could not save template file.")) return else: self.mainWindow().setWindowTitle(template_name) self.setDocumentFile(docFile) docFile.close() if self.copy_template_file: self.copy_template_file.close()
class FileSystemItem(QObject): """ An element in the FileSystemModel. """ iconProvider = QFileIconProvider() fileExtensions = ['*.qlr'] xmlSearchableTags = ['title', 'abstract','layername', 'attribution'] def __init__(self, file, recurse = True, recursion_counter = None, namingregex = None): super(FileSystemItem, self).__init__() # Raise exception if root path has too many child elements if recursion_counter: recursion_counter.increment() if isinstance(file, QFileInfo): self.fileinfo = file else: self.fileinfo = QFileInfo(file) self.fullpath = self.fileinfo.absoluteFilePath() self.basename = self.fileinfo.completeBaseName() self.displayname = self.fileinfo.fileName() if self.fileinfo.isDir() else self.fileinfo.completeBaseName() if namingregex: self.displayname = namingregex.match(self.displayname).group(1) self.icon = FileSystemItem.iconProvider.icon(self.fileinfo) self.isdir = self.fileinfo.isDir() self.children = [] if self.isdir else None if self.isdir and recurse: qdir = QDir(self.fullpath) for finfo in qdir.entryInfoList( FileSystemItem.fileExtensions , QDir.Files | QDir.AllDirs | QDir.NoDotAndDotDot,QDir.Name): self.children.append(FileSystemItem(finfo, recurse, recursion_counter, namingregex)) else: # file # Populate this if and when needed self.searchablecontent = None def filtered(self, filter): """ Filters the root path. :filter is a string. Is it contained in the basename or displayname then this item will be rendered. :return: the directory item. If nothing is found returns None. """ if not filter: return self filterlower = filter.lower() namematch = self.name_matches(filter) if self.isdir: if namematch: # Stop searching. Return this dir and all sub items return FileSystemItem(self.fullpath, True) else: # Only return dir if at least one sub item is a filter match diritem = FileSystemItem(self.fullpath, False) for child in self.children: childmatch = child.filtered(filter) if childmatch is not None: diritem.children.append((childmatch)) if len(diritem.children) > 0: return diritem else: if self.searchablecontent is None: self.searchablecontent = self.get_searchable_content().lower() if namematch or self.content_matches(filter): return FileSystemItem(self.fullpath, False) return None def matches(self, searchterm): """Returns true if this item mathces the searchterm""" return self.name_matches(searchterm) or self.content_matches(searchterm) def name_matches(self, searchterm): """Returns true if the searchterm matches the name of this item""" lowered = searchterm.lower() return lowered in self.basename.lower() or lowered in self.displayname.lower() def content_matches(self, searchterm): """Returns True if the searchterm matches content of this item""" if self.isdir: return False lowered = searchterm.lower() if self.searchablecontent is None: self.searchablecontent = self.get_searchable_content().lower() return lowered in self.searchablecontent def get_searchable_content(self): """ Pulls out tags from the object and returns them in order to be used by the filtered() method. """ f = QFile(self.fileinfo.absoluteFilePath()) f.open(QIODevice.ReadOnly) #stream = QTextStream(f) #stream.setCodec("UTF-8") try: doc = QDomDocument() doc.setContent( f.readAll() ) docelt = doc.documentElement() texts = [] for tagName in FileSystemItem.xmlSearchableTags: nodes = docelt.elementsByTagName(tagName) for i in range(nodes.count()): node = nodes.at(i) value = node.firstChild().toText().data() #print value texts.append( value ) # Add keywords nodes = docelt.elementsByTagName("keywordList") for i in range(nodes.count()): kwnode = nodes.at(i) valnodes = kwnode.toElement().elementsByTagName("value") for j in range(valnodes.count()): value = valnodes.at(j).firstChild().toText().data() texts.append(value) return u' '.join(texts) finally: f.close()
class SCJ(QThread): lock = QMutex() def __init__(self, file=None, format=None, createDir=False): super(SCJ, self).__init__() self.format = format self.filename = file self.file = QFileInfo(self.filename) self.file.makeAbsolute() self.suffix = self.file.suffix() if createDir: self.outputdir = u"%s-%s" % (self.file.path(), self.format) else: self.outputdir = self.file.path() self.output = u"%s%c%s.%s" % ( self.outputdir, QDir.separator().unicode(), self.file.completeBaseName(), self.format) if self.format != "mp3": self.command = [ u"/usr/bin/sox", u"-S", u"%s" % self.filename, u"-t", u"%s" % self.format, u"%s" % self.output ] self.pipecmd = None else: self.command = [ u"/usr/bin/sox", u"-S", u"%s" % self.filename, u"-t", u"wav", u"-" ] self.pipecmd = [ u"/usr/bin/ffmpeg", u"-y", u"-i", u"-", u"-f", u"%s" % self.format, u"%s" % self.output ] self.value = 0 self.process = None self.retCode = None self.running = False self.log = QString(u"") def setProgress(self, value): self.value = value self.emit(SIGNAL("progress(int)"), self.value) def mkdir(self, path): directory = QDir(path) SCJ.lock.lock() if not directory.exists() : if not directory.mkpath(path) : self.emit(SIGNAL("error(QString)"), QString(self.trUtf8("Cannot create %s" % path))) SCJ.lock.unlock() def run(self): self.running = True self.mkdir(self.outputdir) self.process = Process( self.command, stdinput = None) if self.pipecmd : self.pipe = Process( self.pipecmd, stdinput = self.process.stdout) self.process.stdout.close() self.emit(SIGNAL("void started()")) while self.retCode == None : try: self.progression() except IOError as e: pass self.retCode = self.process.poll() self.usleep(10) self.running = False self.end() def resume(self): if self.process : try : self.process.send_signal(signal.SIGCONT) except OSError : pass def stop(self): if self.process : try : self.process.send_signal(signal.SIGSTOP) except OSError : pass def cancel(self): if self.process : try : try: self.process.terminate() self.process.wait() except Exception as e: self.process.kill() except OSError as e : pass self.running = False def end(self): if self.retCode != 0 : self.emit(SIGNAL("error(QString)"), self.trUtf8("Code de retour sox : %d\n%s" % (self.retCode, self.log))) else: if mp3tags : self.set_tags() self.setProgress(100) self.emit(SIGNAL("finished()")) def progression(self): """ Recupération de la progression du process en cours """ line = self.process.stderr.readline() if re.match(u'^In:.*', line): val = re.findall(u"[\.\d]+%", line)[0] self.setProgress(float(val[:-1])) else : self.log.append(line) def set_tags(self): """ Update audio file metadata (Id3 tags...) """ if self.format != "mp3": return tags = mutagen.File(u"%s" % self.filename, easy = True) audio = EasyID3(u"%s" % self.output) for key in tags.keys(): # Ugly hack to have the year in the mp3 metadata if key == "year": audio["date"] = tags[key] else: if key in audio.valid_keys : audio[key] = tags[key] audio.save()
def testCase(self): self.TEST_DATA_DIR = unitTestDataPath() tmppath = tempfile.mkdtemp() for file in glob.glob( os.path.join(self.TEST_DATA_DIR, 'france_parts.*')): shutil.copy(os.path.join(self.TEST_DATA_DIR, file), tmppath) vectorFileInfo = QFileInfo(tmppath + "/france_parts.shp") mVectorLayer = QgsVectorLayer(vectorFileInfo.filePath(), vectorFileInfo.completeBaseName(), "ogr") QgsMapLayerRegistry.instance().addMapLayers([mVectorLayer]) # create composition with composer map mMapRenderer = QgsMapRenderer() layerStringList = [] layerStringList.append(mVectorLayer.id()) mMapRenderer.setLayerSet(layerStringList) mMapRenderer.setProjectionsEnabled(True) mMapRenderer.setMapUnits(QGis.Meters) # select epsg:2154 crs = QgsCoordinateReferenceSystem() crs.createFromSrid(2154) mMapRenderer.setDestinationCrs(crs) self.mComposition = QgsComposition(mMapRenderer) self.mComposition.setPaperSize(297, 210) # fix the renderer, fill with green props = {"color": "0,127,0"} fillSymbol = QgsFillSymbolV2.createSimple(props) renderer = QgsSingleSymbolRendererV2(fillSymbol) mVectorLayer.setRendererV2(renderer) # the atlas map self.mAtlasMap = QgsComposerMap(self.mComposition, 20, 20, 130, 130) self.mAtlasMap.setFrameEnabled(True) self.mComposition.addComposerMap(self.mAtlasMap) # the atlas self.mAtlas = self.mComposition.atlasComposition() self.mAtlas.setCoverageLayer(mVectorLayer) self.mAtlas.setEnabled(True) self.mComposition.setAtlasMode(QgsComposition.ExportAtlas) # an overview mOverview = QgsComposerMap(self.mComposition, 180, 20, 50, 50) mOverview.setFrameEnabled(True) mOverview.setOverviewFrameMap(self.mAtlasMap.id()) self.mComposition.addComposerMap(mOverview) nextent = QgsRectangle(49670.718, 6415139.086, 699672.519, 7065140.887) mOverview.setNewExtent(nextent) # set the fill symbol of the overview map props2 = {"color": "127,0,0,127"} fillSymbol2 = QgsFillSymbolV2.createSimple(props2) mOverview.setOverviewFrameMapSymbol(fillSymbol2) # header label self.mLabel1 = QgsComposerLabel(self.mComposition) self.mComposition.addComposerLabel(self.mLabel1) self.mLabel1.setText("[% \"NAME_1\" %] area") self.mLabel1.setFont(QgsFontUtils.getStandardTestFont()) self.mLabel1.adjustSizeToText() self.mLabel1.setSceneRect(QRectF(150, 5, 60, 15)) qWarning( "header label font: %s exactMatch:%s" % (self.mLabel1.font().toString(), self.mLabel1.font().exactMatch())) # feature number label self.mLabel2 = QgsComposerLabel(self.mComposition) self.mComposition.addComposerLabel(self.mLabel2) self.mLabel2.setText("# [%$feature || ' / ' || $numfeatures%]") self.mLabel2.setFont(QgsFontUtils.getStandardTestFont()) self.mLabel2.adjustSizeToText() self.mLabel2.setSceneRect(QRectF(150, 200, 60, 15)) qWarning( "feature number label font: %s exactMatch:%s" % (self.mLabel2.font().toString(), self.mLabel2.font().exactMatch())) self.filename_test() self.autoscale_render_test() self.autoscale_render_test_old_api() self.fixedscale_render_test() self.predefinedscales_render_test() self.hidden_render_test() shutil.rmtree(tmppath, True)
def importXMLFromFile(self): ''' NO DOCUMENTATION ''' assert self.has_selected_item() # print "importXMLFromFile" # First, prompt the user for the filename to read in start_dir = '' opus_home = os.environ.get('OPUS_HOME') if opus_home: start_dir_test = os.path.join(opus_home, 'project_configs') if start_dir_test: start_dir = start_dir_test configDialog = QFileDialog() filter_str = QString("*.xml") fd = configDialog.getOpenFileName( self.manager.base_widget, "Please select an xml file to import...", start_dir, filter_str) # Check for cancel if len(fd) == 0: return fileName = QString(fd) fileNameInfo = QFileInfo(QString(fd)) fileNameInfoBaseName = fileNameInfo.completeBaseName() fileNameInfoName = fileNameInfo.fileName().trimmed() fileNameInfoPath = fileNameInfo.absolutePath().trimmed() # Pass that in to create a new XMLConfiguration xml_config = XMLConfiguration(str(fileNameInfoName), str(fileNameInfoPath)) xml_node = xml_config.full_tree.getroot() if len(xml_node) == 0: raise ValueError('Loading node from XML file failed. ' 'No node definition found') xml_node = xml_node[0] parent_node = self.selected_item().node allowed_parent_tags = {"tool": ["tool_group"], \ "class_module": ["tool"], \ "path_to_tool_modules": ["tool_library"], \ "tool_library": ["data_manager"], \ "tool_group": ["tool_library"], \ "params": ["tool"], \ "param": ["params"], \ "tool_config": ["tool_set"], \ "tool_set": ["tool_sets"], \ "tool_sets": ["data_manager"]} if parent_node.tag not in allowed_parent_tags[xml_node.tag]: MessageBox.error( mainwindow=self.view, text='Invalid Xml insert', detailed_text= ('Xml insert of node of type "%s" failed. ' 'Invalid type of parent node is "%s" - needs to be one of %s' % (xml_node.tag, parent_node.tag, str(allowed_parent_tags[xml_node.tag])))) return # Insert it into the parent node from where the user clicked name = xml_node.get('name') if xml_node.get('name') is not None else '' if self.model.insertRow(0, self.selected_index(), xml_node) is False: MessageBox.error( mainwindow=self.view, text='Xml Insert Failed', detailed_text= ('Xml insert of node with name "%s" failed - ' 'most likely because there is already a node with that name.' % name)) return
def _create_perimeter(self): """Calls methods for creating and loading perimeter layer.""" try: succes, layer = self.dW.check_layer(self) if not succes: return if layer.featureCount() == 0: self.set_text_statusbar.emit( u'Aktivní vrstva neobsahuje žádný prvek.', 10, True) return editing = self.dW.check_editing() title = u'Uložit vrstvu obvodu jako...' filters = u'.shp (*.shp)' perimeterLayerFilePath = self.dW.open_file_dialog( title, filters, False) if perimeterLayerFilePath: self.set_text_statusbar.emit(u'Vytvářím vrstvu obvodu...', 0, False) fileInfo = QFileInfo(perimeterLayerFilePath) if not fileInfo.suffix() == u'shp': perimeterLayerFilePath = \ fileInfo.absoluteFilePath() + u'.shp' fileInfo = QFileInfo(perimeterLayerFilePath) selectedFeaturesIds = layer.selectedFeaturesIds() perimeterLayerName = fileInfo.completeBaseName() loadedLayer = self.dW.check_loaded_layers( perimeterLayerFilePath) perimeterLayer = self._create_perimeter_layer( layer, perimeterLayerFilePath, self.categoryName, perimeterLayerName, loadedLayer) QgsApplication.processEvents() loadedLayer = self.dW.check_loaded_layers( perimeterLayerFilePath) if loadedLayer: self.iface.actionDraw().trigger() self.set_perimeter_layer(loadedLayer, False) self.sync_perimeter_map_layer_combo_box() else: QgsMapLayerRegistry.instance().addMapLayer(perimeterLayer) layer.selectByIds(selectedFeaturesIds) self.iface.setActiveLayer(layer) if editing: self.toggleEditingAction.trigger() self.set_text_statusbar.emit(u'Obvod byl úspešně vytvořen.', 15, False) except: self.dW.display_error_messages(self, u'Error creating perimeter.', u'Chyba při vytváření obvodu.')