def __init__(self, iface):
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'SUEWSAnalyzer_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Create the dialog (after translation) and keep reference
self.dlg = SUEWSAnalyzerDialog()
# self.layerComboManagerPolygrid = VectorLayerCombo(self.dlg.comboBox_Polygrid, initLayer="",
# options={"geomType": QGis.Polygon})
# fieldgen = VectorLayerCombo(self.dlg.comboBox_Polygrid, initLayer="", options={"geomType": QGis.Polygon})
# self.layerComboManagerPolyField = FieldCombo(self.dlg.comboBox_Field, fieldgen)
self.layerComboManagerPolygrid = QgsMapLayerComboBox(self.dlg.widgetPolygrid)
self.layerComboManagerPolygrid.setCurrentIndex(-1)
self.layerComboManagerPolygrid.setFilters(QgsMapLayerProxyModel.PolygonLayer)
self.layerComboManagerPolygrid.setFixedWidth(175)
self.layerComboManagerPolyfield = QgsFieldComboBox(self.dlg.widgetField)
self.layerComboManagerPolyfield.setFilters(QgsFieldProxyModel.Numeric)
self.layerComboManagerPolygrid.layerChanged.connect(self.layerComboManagerPolyfield.setLayer)
self.dlg.pushButtonHelp.clicked.connect(self.help)
self.dlg.pushButtonRunControl.clicked.connect(self.get_runcontrol)
self.dlg.pushButtonSave.clicked.connect(self.geotiff_save)
self.dlg.runButtonPlot.clicked.connect(self.plotpoint)
self.dlg.runButtonSpatial.clicked.connect(self.spatial)
self.dlg.comboBox_POIField.activated.connect(self.changeGridPOI)
self.dlg.comboBox_POIYYYY.activated.connect(self.changeYearPOI)
self.dlg.comboBox_SpatialYYYY.activated.connect(self.changeYearSP)
self.fileDialog = QFileDialog()
self.fileDialognml = QFileDialog()
self.fileDialognml.setNameFilter("(RunControl.nml)")
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&SUEWS Analyzer')
# TODO: We are going to let the user set this up in a future iteration
# self.toolbar = self.iface.addToolBar(u'SUEWSAnalyzer')
# self.toolbar.setObjectName(u'SUEWSAnalyzer')
self.outputfile = None
self.unit = None
self.resout = None
self.fileCode = None
self.gridcodemetmat = []
def __init__(self, main_window_ref):
super(UIDefineNewColorWidget, self).__init__()
uic.loadUi(currentdir + '/ui_files/DefineNewColor.ui', self)
self._main_window_ref = main_window_ref
self._MAX_COLORS = 10
# initialize image selection dialog
self.dlgLoadImage = QFileDialog()
self.dlgLoadImage.setFileMode(QFileDialog.ExistingFile)
self.dlgLoadImage.setFilter("Image files (*.png *.jpeg *.jpg *.bmp)")
self.dlgLoadImage.setAcceptMode(QFileDialog.AcceptOpen)
# initialize color saving dialog
self.dlgSaveColors = QFileDialog()
self.dlgSaveColors.setFileMode(QFileDialog.AnyFile)
self.dlgSaveColors.setFilter("Color files (*.clr)")
self.dlgSaveColors.setAcceptMode(QFileDialog.AcceptSave)
# initialize graphics view objects and color array
self.btnClearColorsClicked()
# connect buttons to functions
self.btnLoadImage.clicked.connect(self.btnLoadImageClicked)
self.btnSaveColors.clicked.connect(self.btnSaveColorsClicked)
self.btnClearColors.clicked.connect(self.btnClearColorsClicked)
def init(cls):
cls._file_save_dialog = QFileDialog()
#configuración del fileDialog de Qt
cls._file_save_dialog.setAcceptMode(
QFileDialog.AcceptSave) #Sólo se acepta salvar fichero
cls._file_save_dialog.setViewMode(
QFileDialog.Detail) #La vista se muestra en detalles
cls._file_load_dialog = QFileDialog()
#configuración del fileDialog de Qt
cls._file_load_dialog.setAcceptMode(
QFileDialog.AcceptOpen) #Sólo se acepta abrir fichero
cls._file_load_dialog.setViewMode(
QFileDialog.Detail) #La vista se muestra en detalles
def import_profile(self):
""" Import minimum needs from an existing json file.
The minimum needs are loaded from a file into the table. This state
is only saved if the form is accepted.
"""
# noinspection PyCallByClass,PyTypeChecker
file_name_dialog = QFileDialog(self)
file_name_dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
file_name_dialog.setNameFilter(self.tr('JSON files (*.json *.JSON)'))
file_name_dialog.setDefaultSuffix('json')
current_directory = os.path.dirname(__file__)
path_name = os.path.join(
current_directory, '..', '..', 'resources', 'minimum_needs')
file_name_dialog.setDirectory(path_name)
if file_name_dialog.exec_():
file_name = file_name_dialog.selectedFiles()[0]
else:
return -1
if self.minimum_needs.read_from_file(file_name) == -1:
return -1
self.clear_resource_list()
self.populate_resource_list()
self.switch_context(self.profile_edit_page)
def importXMLFromFile(self):
''' NO DOCUMENTATION '''
# print "importXMLFromFile"
# First, prompt the user for the filename to read in
start_dir = paths.get_project_configs_path()
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)
# Pass that in to create a new XMLConfiguration
try:
options = ''
xml_tree = load_xml_file(str(fileName))
xml_node = xml_tree.getroot()
options = ' or another node in the tree view'
self.import_from_node(xml_node)
except Exception, e:
MessageBox.error(mainwindow=self.view,
text='Cannot insert XML file.',
detailed_text='XML insert failed. '
'%s. '
'Please select another XML file%s.' %
(e, options))
return
def askExportPath(self):
newPath = QFileDialog().getSaveFileName(self, self.tr("CSV path"),
self.exportPath)
if len(newPath):
self.exportPath = unicode(newPath.toUtf8(), 'utf-8')
self.exportPathLineEdit.clear()
self.exportPathLineEdit.insert(self.exportPath)
def download(self):
if not empty(self.subtitle.url):
if self.subtitle.url.endswith('.rar'):
ext = '.rar'
elif self.subtitle.url.endswith('.srt'):
ext = '.srt'
else:
ext = '.zip'
fileDial = QFileDialog(self,
'Save "%s" subtitle file' % self.subtitle.name,
'%s%s' % (self.subtitle.name, ext),
'all files (*)')
fileDial.setAcceptMode(QFileDialog.AcceptSave)
fileDial.setLabelText(QFileDialog.Accept, 'Save subtitle file')
fileDial.setLabelText(QFileDialog.FileName, 'Subtitle file name')
ok = (fileDial.exec_() == 1)
if not ok:
return
result = fileDial.selectedFiles()
if len(result) > 0:
dest = result[0]
data = self.backend.get_subtitle_file(self.subtitle.id)
try:
with open(dest, 'w') as f:
f.write(data)
except IOError as e:
print('Unable to write subtitle file in "%s": %s' % (dest, e),
file=self.stderr)
return 1
return
def getImageFileNamesToOpen(cls, parent_window, defaultDirectory):
"""
Launch an "Open File" dialog to ask the user for one or more image files.
"""
extensions = OpDataSelection.SupportedExtensions
filter_strs = ["*." + x for x in extensions]
filters = ["{filt} ({filt})".format(filt=x) for x in filter_strs]
filt_all_str = "Image files (" + ' '.join(filter_strs) + ')'
fileNames = []
if ilastik_config.getboolean("ilastik", "debug"):
# use Qt dialog in debug mode (more portable?)
file_dialog = QFileDialog(parent_window, "Select Images")
file_dialog.setOption(QFileDialog.DontUseNativeDialog, True)
# do not display file types associated with a filter
# the line for "Image files" is too long otherwise
file_dialog.setFilters([filt_all_str] + filters)
file_dialog.setNameFilterDetailsVisible(False)
# select multiple files
file_dialog.setFileMode(QFileDialog.ExistingFiles)
file_dialog.setDirectory(defaultDirectory)
if file_dialog.exec_():
fileNames = file_dialog.selectedFiles()
else:
# otherwise, use native dialog of the present platform
fileNames = QFileDialog.getOpenFileNames(parent_window,
"Select Images",
defaultDirectory,
filt_all_str)
# Convert from QtString to python str
fileNames = map(encode_from_qstring, fileNames)
return fileNames
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.ui = uic.loadUi("mainwindow.ui")
self.ui.closeEvent = self.closeEvent
self.steppingTimer = QtCore.QTimer()
self.calibrTimer = QtCore.QTimer()
self.calibrHomeTimer = QtCore.QTimer()
self.calibrFWTimer = QtCore.QTimer()
self.measTimer = QtCore.QTimer()
self.angleUpdateTimer = QtCore.QTimer()
self.stepperStateTimer = QtCore.QTimer()
self.oscReadTimer = QtCore.QTimer()
self.config = configparser.ConfigParser()
self.config.read('settings.ini')
print(sys.argv[0], self.config.sections())
self.globalSettingsDict = self.config[
'GLOBAL'] #.read('globalSettings.ini')
self.updateSettingsTable()
self.uiConnect()
self.initUi()
self.fileDialog = QFileDialog(self)
#self.initET1255()
self.tmpData = [] #[[0,0,0]]
self.calibrData = np.array([]) #[0,0,0])
#self.SMD = SMD004()
#self.extLaserStrob = laserStrob(0.1)
self.oscillo = HAMEG()
self.oscilloLastMaster = 'HAMEG'
def detect(self):
pf = platform.system()
if pf == 'Windows':
self.mosesPath = self.findRegistryPath()
if self.mosesPath:
return self.checkMosesInstall()
else:
if not doQuestion(
'Cannot find Moses installation, click "Yes" to '
'manually set the Moses path, click "No" to exit.'):
return False
# If not found, use a dialog.
startdir = 'C:\\'
if "ProgramFiles(x86)" in os.environ:
startdir = os.environ["ProgramFiles(x86)"]
elif "ProgramFiles" in os.environ:
startdir = os.environ["ProgramFiles"]
else:
pass
dialog = QFileDialog(None, directory=startdir)
dialog.setFileMode(QFileDialog.Directory)
dialog.setViewMode(QFileDialog.Detail)
dialog.setOptions(QFileDialog.ShowDirsOnly)
if dialog.exec_():
self.mosesPath = str(dialog.selectedFiles()[0])
return self.checkMosesInstall()
else:
doAlert("Failed to find Moses Installation path, exit.")
return False
else:
doAlert("Platform %s not supported yet" % pf)
return False
def accept(self):
if self.collectedDataDict:
exportMap = self.getExportFieldMap()
cleanedDataDict = []
for feature in self.collectedDataDict:
cleanedFeat = {}
for key,value in feature.iteritems():
if key == "GEOMETRY":
if "," in value: #geometry comes from google drive
value = value.replace(" ",";").replace(",", " ") # fixed comma/space/semicolon mismatch between odk aggregate and google drive
cleanedFeat["GEOMETRY"] = value
elif key[-7:] == "ODKUUID":
cleanedFeat["ODKUUID"] = value
elif key in exportMap:
cleanedFeat[exportMap[key]] = self.cleanURI(value) #Download and provide local URI if value is internet URI
cleanedDataDict.append(cleanedFeat)
if self.syncroCheckBox.isChecked():
self.updateLayer(self.getCurrentLayer(),cleanedDataDict)
else:
geojsonDict = self.module.settingsDlg.getLayerFromTable(cleanedDataDict)
if geojsonDict:
self.hide()
workDir = QgsProject.instance().readPath("./")
geoJsonFileName = QFileDialog().getSaveFileName(None, self.tr("Save as GeoJson"), workDir, "*.geojson")
if QFileInfo(geoJsonFileName).suffix() != "geojson":
geoJsonFileName += ".geojson"
with open(os.path.join(workDir,geoJsonFileName), "w") as geojson_file:
geojson_file.write(json.dumps(geojsonDict))
layer = self.iface.addVectorLayer(os.path.join(workDir,geoJsonFileName), QFileInfo(geoJsonFileName).baseName(), "ogr")
QgsMapLayerRegistry.instance().addMapLayer(layer)
def export(self):
self.export_thread_pool.waitForDone(0)
acquisitions = None
if self.model is not None:
acquisitions = self.model.data
if not acquisitions:
self.iface.messageBar().pushMessage("Error",
"No data to export.",
level=QgsMessageBar.CRITICAL)
else:
# open file ui
select_file_ui = QFileDialog()
starting_file = self.export_file or os.path.expanduser("~")
export_file = select_file_ui.getSaveFileName(
None, "Choose output file", starting_file, SELECT_FILTER)
if export_file:
self.export_file = export_file
self.init_progress_bar(0)
export_runnable = CatalogExportRunnable(
acquisitions, self.export_file)
export_runnable.task_object.task_complete.connect(
self.on_export_complete)
self.export_thread_pool.start(export_runnable)
def __runOpenDialog(self):
startdir = os.path.expanduser("~/")
if self.recent_paths:
startdir = self.recent_paths[0].abspath
if OWImportImages.Modality == Qt.WindowModal:
dlg = QFileDialog(
self,
"Select Top Level Directory",
startdir,
acceptMode=QFileDialog.AcceptOpen,
modal=True,
)
dlg.setFileMode(QFileDialog.Directory)
dlg.setOption(QFileDialog.ShowDirsOnly)
dlg.setDirectory(startdir)
dlg.setAttribute(Qt.WA_DeleteOnClose)
@dlg.accepted.connect
def on_accepted():
dirpath = dlg.selectedFiles()
if dirpath:
self.setCurrentPath(dirpath[0])
self.start()
dlg.open()
else:
dirpath = QFileDialog.getExistingDirectory(
self, "Select Top Level Directory", startdir)
if dirpath:
self.setCurrentPath(dirpath)
self.start()
def saveCvImage(self):
global fileSelected
global videoState
videoState = 'pause'
if fileSelected != "":
dlg = QFileDialog()
#dlg.setNameFilter('PNG files (*.png)')
dlg.setDefaultSuffix('.png')
fileNameImage = dlg.getSaveFileName(self.w, 'Navigate to Directory and Choose a File Name to Save To', 'untitled.png', 'PNG Image (*.png)')
if fileNameImage != "":
try:
print(fileNameImage)
cv2.imwrite(str(fileNameImage),self.grabDataFrame())
print('Saved frame ' + str(frame) + ' as .png')
self.history.insertPlainText('SUCCESS: Saved Frame: ' + str(frame) + ' as PNG\n')
self.history.moveCursor(QTextCursor.End)
except:
self.history.insertPlainText('No PNG Image Generated\n Did Not Specify Proper FileName\n')
self.history.moveCursor(QTextCursor.End)
print('Did Not Specify Proper FileName')
print('No PNG Image Generated')
else:
self.history.insertPlainText('No PNG Image Generated\n Did Not Specify Proper FileName\n')
self.history.moveCursor(QTextCursor.End)
print('Did Not Specify Proper FileName')
print('No PNG Image Generated')
def on_exportPushButton_clicked(self):
if not self.profilesListWidget.currentItem():
QMessageBox.warning(self, self.tr('Warning!'),
self.tr('Error! Select a profile to export!'))
return
fd = QFileDialog()
folder = fd.getExistingDirectory(
caption=self.tr('Select a folder to output'))
if folder == '':
QMessageBox.warning(self, self.tr('Warning!'),
self.tr('Error! Select a output!'))
return
profileName = self.profilesListWidget.currentItem().text()
edgvVersion = self.versionSelectionComboBox.currentText()
try:
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.permissionManager.exportSetting(profileName, edgvVersion,
folder)
QApplication.restoreOverrideCursor()
QMessageBox.warning(self, self.tr('Success!'),
self.tr('Permission successfully exported.'))
except Exception as e:
QApplication.restoreOverrideCursor()
QMessageBox.warning(
self, self.tr('Warning!'),
self.tr('Error! Problem exporting permission: ') +
':'.join(e.args))
def exportXMLToFile(self):
''' NO DOCUMENTATION '''
assert self.has_selected_item()
# Ask the users where they want to save the file
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.getSaveFileName(self.manager.base_widget,
QString("Save As..."),
QString(start_dir), filter_str)
# Check for cancel
if len(fd) == 0:
return
fileNameInfo = QFileInfo(QString(fd))
fileName = fileNameInfo.fileName().trimmed()
fileNamePath = fileNameInfo.absolutePath().trimmed()
saveName = os.path.join(str(fileNamePath), str(fileName))
# proper root node for XmlConfiguration
root_node = Element('opus_project')
import copy
root_node.append(copy.deepcopy(self.selected_item().node))
# Write out the file
ElementTree(root_node).write(saveName)
def download(self, reply):
filepath = reply.url().toString()
#dl = self.showBox('Iniciar download de', filepath)
#if dl == QMessageBox.Yes:
split = urlparse.urlsplit(filepath)
filename = split.path.split("/")[-1]
ofd = QFileDialog()
ofd.setFileMode(QFileDialog.Directory)
ofd.setOption(QFileDialog.ShowDirsOnly)
ofd.setWindowTitle(filename)
if ofd.exec_():
res = ofd.selectedFiles()[0]
path = os.path.join(res, filename)
self.start_download.emit(str(filepath), str(path))
#elif dl == QMessageBox.No:
# pass
#elif dl == QMessageBox.Cancel:
# pass
rep = self.showBox('Tentar reproduzir o arquivo?', filepath)
if rep == QMessageBox.Yes:
self.open_video.emit(filepath, False)
self.close()
main.hide()
elif rep == QMessageBox.No:
pass
elif rep == QMessageBox.Cancel:
pass
def _loadConfig(self):
'''
Load a JSON configuration
'''
# Select config file to load
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.ExistingFile)
dialog.setOption(QFileDialog.ReadOnly)
dialog.setNameFilter('Json file (*.json)')
dialog.setWindowTitle(
QCoreApplication.translate(
'ImportDxfDialog', 'Select the configuration file to load'))
dialog.setSizeGripEnabled(False)
result = dialog.exec_()
if result == 0:
return
selected_files = dialog.selectedFiles()
if len(selected_files) == 0:
return
filename = selected_files[0]
# Load mapping
self.mapping.parseJson(filename)
self._loadLayersMapping()
def _saveToFile(self, sender, startFolder=None):
'save to file'
#filter = "Shape Files (*.shp);;Geojson File (*.geojson);;GML ( *.gml);;Comma separated value File (excel) (*.csv);;MapInfo TAB (*.TAB);;Any File (*.*)"
filter = "ESRI Shape Files (*.shp);;SpatiaLite (*.sqlite);;Any File (*.*)" #show only formats with update capabilty
Fdlg = QFileDialog()
Fdlg.setFileMode(QFileDialog.AnyFile)
fName = Fdlg.getSaveFileName(sender,
"open file",
filter=filter,
directory=startFolder)
if fName:
ext = os.path.splitext(fName)[1]
if "SHP" in ext.upper():
flType = "ESRI Shapefile"
elif "SQLITE" in ext.upper():
flType = "SQLite"
elif "GEOJSON" in ext.upper():
flType = "GeoJSON"
elif "GML" in ext.upper():
flType = "GML"
elif "CSV" in ext.upper():
ftType = "CSV"
elif 'TAB' in ext.upper():
flType = 'MapInfo File'
elif 'KML' in ext.upper():
flType = 'KML'
else:
fName = fName + ".shp"
flType = "ESRI Shapefile"
return (fName, flType)
else:
return None
def doOpenFile(self, selector):
text = {
'ndvi': 'NDVI file (5 Classes)',
'lulc': 'LU/LC (5 Classes)',
'clipShp': 'clipping shapefile'
}
dialog = QFileDialog()
fname = dialog.getOpenFileName(
self.dlg, self.tr("Open {}".format(text[selector])))
if fname:
if selector == 'clipShp':
# it must be a shapefile, let's open it
self.clipLayer = QgsVectorLayer(fname, "Clip", 'ogr')
if not self.clipLayer.isValid():
self.logMsg(
"Could not load vector layer {} with {}".format(
self.clipLayer.name(), fname),
QgsMessageLog.WARNING)
self.dlg.logTextDump.append(
"Could not load vector layer {}".format(
self.clipLayer))
else:
self.dlg.editClipShp.setText(fname)
if selector == 'ndvi':
self.dlg.editNdvi.setText(fname)
if selector == 'lulc':
self.dlg.editLULC.setText(fname)
def saveProjectAs(self):
''' Save the project configuration under a different name '''
try:
# get the location for the new config file on disk
start_dir = paths.OPUS_PROJECT_CONFIGS_PATH
configDialog = QFileDialog()
filter_str = QString("*.xml")
fd = configDialog.getSaveFileName(self, QString("Save As..."),
QString(start_dir), filter_str)
# Check for cancel
if not fd:
return
filename = QString(fd)
# append xml extension if no extension was given
if not filename.endsWith('.xml') and len(filename.split('.')) == 1:
filename = filename + '.xml'
if not self.saveProject(filename):
return
# hack: open the project right after save to properly change the
# 'active project' related parameters
self.openProject(filename)
except:
errorMessage = formatExceptionInfo(custom_message = \
'Unexpected error saving config')
QMessageBox.warning(self, 'Warning', errorMessage)
def project_new_clicked(self):
self.btn_project_new.setChecked(False)
file_dialog = QFileDialog()
file_dialog.setWindowTitle('New project')
file_dialog.setLabelText(QFileDialog.Accept, 'Create')
file_dialog.setNameFilter('Inp files (*.inp)')
if file_dialog.exec_():
inp_file_path = file_dialog.selectedFiles()[0]
if not inp_file_path.lower().endswith('.inp'):
inp_file_path += '.inp'
self.inp_file_path = inp_file_path
self.params.last_project_dir = os.path.dirname(inp_file_path)
lay_utils.remove_layers(self.params)
# Request CRS for layers
self.crs_selector()
self.create_layers(None, self.params.crs)
self.txt_prj_file.setText(self.inp_file_path)
# Prompt for hydaulic options
if self.hydraulics_dialog is None:
self.hydraulics_dialog = HydraulicsDialog(
self, self.params, True)
self.hydraulics_dialog.show()
def export(self):
fileDial = QFileDialog(
self, 'Export "%s" recipe' % self.recipe.title,
'%s.kreml' % self.recipe.title.replace('/', ','),
'Krecipe file (*.kreml);;all files (*)')
fileDial.setAcceptMode(QFileDialog.AcceptSave)
fileDial.setLabelText(QFileDialog.Accept, 'Export recipe')
fileDial.setLabelText(QFileDialog.FileName, 'Recipe file name')
ok = (fileDial.exec_() == 1)
if not ok:
return
result = fileDial.selectedFiles()
if len(result) > 0:
dest = unicode(result[0])
if not dest.endswith('.kreml'):
dest += '.kreml'
data = self.recipe.toKrecipesXml(author=self.backend.name)
try:
with codecs.open(dest, 'w', 'utf-8') as f:
f.write(data)
except IOError as e:
print >> sys.stderr, 'Unable to write Krecipe file in "%s": %s' % (
dest, e)
return 1
return
def saveAsPdf(self,
name=None,
path=None,
saveInAutoGenDir=True,
multipagePdf=None,
openFile=True):
"""if a multipagePdf object is provided, will append the plot to a new page of the pdf object"""
if name == None:
name = self.name
if path == None:
if saveInAutoGenDir:
path = loadSave.getCurrentDir()
import os
file = os.path.join(path, name)
else:
from PyQt4.QtGui import QFileDialog
fd = QFileDialog()
file = fd.getSaveFileName()
else:
import os
file = os.path.join(path, name)
if file[-4:] != ".pdf":
file = file + ".pdf"
if multipagePdf == None:
from matplotlib.backends.backend_pdf import PdfPages
pdf = PdfPages(file)
else:
pdf = multipagePdf
pdf.savefig(self.canvas.fig)
if multipagePdf == None:
pdf.close()
import os
os.startfile(file)
def save_profile_as(self):
"""Save the minimum needs under a new profile name.
"""
# noinspection PyCallByClass,PyTypeChecker
file_name_dialog = QFileDialog(self)
file_name_dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
file_name_dialog.setNameFilter(self.tr('JSON files (*.json *.JSON)'))
file_name_dialog.setDefaultSuffix('json')
file_name_dialog.setDirectory(expanduser('~/.qgis2/minimum_needs'))
if file_name_dialog.exec_():
file_name = file_name_dialog.selectedFiles()[0]
else:
return
file_name = basename(file_name)
file_name = file_name.replace('.json', '')
minimum_needs = {'resources': []}
self.mark_current_profile_as_saved()
for index in xrange(self.resources_list.count()):
item = self.resources_list.item(index)
minimum_needs['resources'].append(item.resource_full)
minimum_needs['provenance'] = self.provenance.text()
minimum_needs['profile'] = file_name
self.minimum_needs.update_minimum_needs(minimum_needs)
self.minimum_needs.save()
self.minimum_needs.save_profile(file_name)
if self.profile_combo.findText(file_name) == -1:
self.profile_combo.addItem(file_name)
self.profile_combo.setCurrentIndex(
self.profile_combo.findText(file_name))
def exportXForm(self, fileName=None, submission_url=None):
workDir = QgsProject.instance().readPath("./")
if not fileName:
fileName = QFileDialog().getSaveFileName(None,
self.tr("Save XForm"),
workDir, "*.xml")
exportingToGDrive = None
elif self.settingsDlg.getCurrentService().hasValue(
'data collection table ID'):
exportingToGDrive = True
else:
exportingToGDrive = None
if QFileInfo(fileName).suffix() != "xml":
fileName += ".xml"
json_out = self.dlg.treeView.renderToDict(
service=self.settingsDlg.getServiceName())
xForm_id = json_out["name"]
if exportingToGDrive: #if exporting to google drive a submission_url is embedded in XFORM
if self.settingsDlg.getCurrentService().getValue(
'data collection table ID') == "": #autocreated
submission_url = self.settingsDlg.setDataSubmissionTable(
xForm_id)
else: #user defined
submission_url = 'https://docs.google.com/spreadsheets/d/%s/edit' % self.settingsDlg.getCurrentService(
).getValue('data collection table ID')
if submission_url:
json_out["submission_url"] = submission_url
survey = create_survey_element_from_dict(json_out)
warnings = []
xform = survey.to_xml(validate=None, warnings=warnings)
with io.open(fileName, "w", encoding="utf8") as xml_file:
xml_file.write(xform)
#with io.open(fileName+'.json', "wb") as json_file:
# json.dump(json_out,json_file)
return xForm_id
def ODKLoadLayerStateAction(self, fileName=None):
if not fileName:
workDir = QgsProject.instance().readPath("./")
fileName = QFileDialog().getOpenFileName(
None, self.tr("Load QGISODK project"), workDir, "*.json")
if fileName:
with open(fileName, "r") as json_file:
restoreDict = json.load(json_file)
ODKProjectName = QFileInfo(fileName).baseName()
self.settingsDlg.importSettings(restoreDict['settings'])
self.dlg.treeView.recover(restoreDict)
self.dlg.setWindowTitle("QGISODK - " + ODKProjectName)
#print restoreDict['targetLayer']['id']
current_idx = self.dlg.layersComboBox.findData(
restoreDict['targetLayer']['id'])
if current_idx == -1:
current_idx = self.dlg.layersComboBox.findText(
restoreDict['targetLayer']['name'])
if current_idx == -1:
current_idx = 0
#print current_idx
#If found sets layers combo box with provided layer, disconnecting update signals....
try:
self.dlg.layersComboBox.currentIndexChanged.disconnect(
self.VectorLayerComboChanged)
except:
pass
self.dlg.layersComboBox.setCurrentIndex(current_idx)
self.dlg.layersComboBox.currentIndexChanged.connect(
self.VectorLayerComboChanged)
S = QSettings()
QgsExpressionContextUtils.setProjectVariable(
'QgisODK_current_project', fileName)
def openInput(self):
# reset labelPadding
self.dlg.labelPadding.setText('Distance to centre (in input unit)')
# file dialog
dialog = QFileDialog()
self.inShapefile = dialog.getOpenFileName(self.dlg,"Open vector file", self.inputPath)
if self.inShapefile == '':
return True
self.cleanErrorMessage()
# open file, guess driver
self.inDataSource = ogr.Open(self.inShapefile, 0)
if self.inDataSource is None:
return False
self.inLayer = self.inDataSource.GetLayer()
self.spatialRef = self.inLayer.GetSpatialRef()
# update interface
if self.spatialRef.GetAttrValue('unit') is not None:
self.dlg.labelPadding.setText('Distance to centre (in input unit: {})'.format(self.spatialRef.GetAttrValue('unit')))
# change padding default increment according to type
if self.spatialRef.GetAttrValue('unit').lower() in ['meters','meter']:
self.dlg.spinBoxPaddingX.setSingleStep(1.0)
self.dlg.spinBoxPaddingY.setSingleStep(1.0)
else:
self.dlg.spinBoxPaddingX.setSingleStep(0.1)
self.dlg.spinBoxPaddingY.setSingleStep(0.1)
# once all done, update text field
self.dlg.textFileInput.setText(self.inShapefile)
# and save path for next time
self.inputPath = os.path.dirname(self.inShapefile);
return True
def processtrigger(self, q):
self.set_params()
if q.text() == 'Загрузить данные':
dlg = QFileDialog()
dlg.setFileMode(QFileDialog.AnyFile)
dlg.setFileMode(QFileDialog.ExistingFiles)
filenames = QStringListModel()
if dlg.exec_():
filenames = dlg.selectedFiles()
if self.active_class_item is not None:
for f in filenames:
self.active_class_item.addChild(QTreeWidgetItem([str(f)]))
img = imread(f, mode='P')
lbl = self.active_class_item.text(0)[
-1] #считаем, что не будет двузначных меток
if self.active_class_item.text(0) == 'Тест':
self.mController.add_test(img, self.params)
else:
self.mController.add_data(img, lbl, self.params)
elif q.text() == 'Очистить':
count = self.active_class_item.childCount()
for _ in range(count):
self.active_class_item.removeChild(
self.active_class_item.child(0))
if self.active_class_item.text(0) == 'Тест':
self.mController.delete_test()
else:
lbl = self.active_class_item.text(0)[-1]
self.mController.delete_data(lbl)
self.active_class_item = None
def open_image(self, checked=False, path=None):
if path is None:
dlg = QFileDialog()
dlg.setFileMode(QFileDialog.ExistingFile)
dlg.setFilter("Image Files (*.NEF *.TIFF *.TIF)")
filenames = []
if dlg.exec_():
filenames = dlg.selectedFiles()
if len(filenames) >= 1:
path = unicode(filenames[0])
else:
#TODO: add messagebox
return
if os.path.isfile(path):
filename = os.path.basename(path)
if path not in self.current_images:
im = cv2.imread(path, -1)
widget = QImageWidget()
visualization = im.copy()
if visualization .shape[0] > self.screen_size.height():
visualization = self.image_resize(visualization , height=self.screen_size.height()-200)
if visualization .shape[1] > self.screen_size.width():
visualization = self.image_resize(visualization , width=self.screen_size.width()-200)
widget.set_opencv_image(visualization )
new_image = {"filename": filename, "path": path, "data":im, "widget": widget}
self.create_image_tab(new_image)
else:
#TODO: Go to tab
pass
self.current_images.append(new_image)
self.statusBar().showMessage("Opened file %s"%filename)
else:
mb = QMessageBox("ERROR in path", "Path to file \n%s\ncould not be found."%path, QMessageBox.Warning, QMessageBox.Ok, 0, 0)
mb.exec_()
