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