def _onComputeTranslationButtonPressed(self):
self._onMethodChanged()
m = self.mainOperator.TranslationVectors.meta
maxt = m.shape[0]
progress = QProgressDialog("Computing Translation Vectors...", "Stop", 0, maxt)
progress.setWindowModality(Qt.ApplicationModal)
progress.setMinimumDuration(0)
progress.setCancelButtonText(QString())
progress.forceShow()
reqs = []
for t in range(maxt):
reqs.append(self.mainOperator.TranslationVectorsComputation([t]))
reqs[-1].submit()
for i, req in enumerate(reqs):
progress.setValue(i)
if progress.wasCanceled():
req.cancel()
else:
req.wait()
progress.setValue(maxt)
roi = SubRegion(self.mainOperator.TranslationVectors, start=5*(0,), stop=m.shape)
self.mainOperator.TranslationVectors.setDirty(roi)
print 'Translation Vector Computation: done.'
def loadList(self, externalActions=None, itemActions=None):
try:
dirList = [l for l in os.listdir(self.directory)
if (l.endswith(self.extention)
and (not self.disextention
or not l.endswith(self.disextention))
)]
except:
try:
if os.path.exists(os.path.join(os.getcwd(), self.name)):
self.directory = os.path.abspath(
os.path.join(os.getcwd(), self.name))
else:
self.directory = os.getcwd()
dirList = [l for l in os.listdir(self.directory)
if (l.endswith(self.extention)
and (not self.disextention
or not l.endswith(self.disextention))
)]
except:
return
progress = QProgressDialog(
"Loading %s elements" % self.clName,
QString(), 0, len(dirList), self)
progress.setWindowTitle("Load Elements")
progress.setWindowModality(Qt.WindowModal)
progress.forceShow()
for i in range(len(dirList)):
fname = dirList[i]
name = self.nameFromFile(fname)
dlg = self.createElement(name)
dlg.load()
if hasattr(dlg, "addContextMenu"):
dlg.addContextMenu(itemActions)
actions = externalActions if externalActions else {}
if hasattr(dlg, "connectExternalActions"):
dlg.connectExternalActions(**actions)
el = LabeledObject(name, dlg)
self.elements[id(el)] = el
if el.instance is not None:
el.instance.id = el.id
logger.info("loading %s" % name)
progress.setValue(i)
progress.setValue(len(dirList))
progress.close()
def open(self):
dialog = QFileDialog(self, "Open LAS")
dialog.setFileMode(QFileDialog.ExistingFiles)
if dialog.exec_():
filenames = dialog.selectedFiles()
show_progress = len(filenames) > 1
if show_progress:
progress = QProgressDialog(self.app_window)
progress.forceShow()
progress.setMinimum(0)
progress.setMaximum(len(filenames) - 1)
for filename in filenames:
if LasFile.is_lasfile(filename):
lasfile = LasFile.from_(filename)
if show_progress:
progress.setValue(progress.value() + 1)
else:
raise "%s is not a las file!!" % filename
self.app_window.create_new_track_panel(lasfile)
if show_progress:
progress.hide()
def processScans(self):
base = self.getBaseDirectory(True, self.scans)
out_file, _selectedfilter = getsavefilename(
caption=
"Choose file for summary output - the directory is also used for rebinned and/or summed scans",
basedir=path.join(base, 'summary.txt'))
if not out_file:
return
progress = QProgressDialog("Process scans...", "Stop", 0,
2 * len(self.scans), self)
progress.setWindowModality(Qt.WindowModal)
progress.forceShow()
progress.setValue(0)
from mythen import load_all, process_and_save, report_processing
data, files = load_all(self.scans, None, None, progress=progress)
summed = True
rebinned = True
if self.rebin_rb.isChecked():
summed = False
elif self.sum_rb.isChecked():
rebinned = False
process_and_save(data,
self.angle_spinbox.value(),
self.delta_spinbox.value(),
rebinned,
summed,
files,
out_file,
progress=progress,
weights=self.weight_cb.isChecked(),
ext='.xye')
report_processing(files, out_file, self.angle_spinbox.value(),
[self.delta_spinbox.value()])
progress.setValue(progress.maximum())
def addScanNumbers(self):
result = self.range_dialog.exec_()
if result == QDialog.Accepted:
text = self.range_ui.range_edit.text()
if text:
not_found = []
numbers = mythen.parse_range_list(text)
year, visit = self.getYearAndVisit()
progress = QProgressDialog(
"Locating scan files from numbers...", "Stop", 0,
len(numbers), self)
progress.setWindowModality(Qt.WindowModal)
progress.forceShow()
progress.setValue(0)
for n in numbers:
progress.setValue(progress.value() + 1)
if progress.wasCanceled():
break
files = mythen.find_mythen_files(
n, visit=visit,
year=year) # FIXME needs to be in separate thread(!)
if files:
files = [f for f in files if f not in self.scans]
self.scans.extend(files)
self.scans_model.setStringList(self.scans)
else:
not_found.append(n)
progress.setValue(progress.maximum())
if not_found:
error = QErrorMessage(self)
msg = "The following numbers were not found: "
for n in not_found:
msg = msg + str(n) + ", "
error.showMessage(msg[:-2])
class BAONQtApplication(QApplication):
BACKUP_DIALOG_CAPTION = 'Rename Plan Backup Detected'
BACKUP_DIALOG_ERROR_CAPTION = 'Error'
BACKUP_INTRO_TEXT = 'BAON has detected a backed up rename plan from a previous run of the '\
'application. This suggests that the application crashed partway through executing a rename operation. The '\
'files may have been left in an inconsistent state.'
BACKUP_PROMPT_TEXT = 'What do you want to do?'
REVERT_BACKUP_PROGRESS_TEXT = 'Reverting the rename operation'
SUCCESS_DIALOG_CAPTION = 'Success'
WARNING_DIALOG_CAPTION = 'Warning'
BACKUP_DELETED_DIALOG_TEXT =\
'The backed up plan has been deleted. Further runs of the application will proceed normally.'
BACKUP_REVERTED_SUCCESS_DIALOG_TEXT = 'The rename operation has been reverted successfully. The directory state '\
'should now have been completely restored.'
BACKUP_REVERTED_WARNING_DIALOG_TEXT = 'There were inconsistencies while trying to revert the previous rename '\
'operation. The directory state may not have been fully restored.'
REVERT_BACKUP_BUTTON_TEXT = 'Revert the rename (recommended)'
DELETE_BACKUP_BUTTON_TEXT = 'Delete the backup file'
EXAMINE_BACKUP_BUTTON_TEXT = 'Examine the plan in a text editor'
QUIT_BUTTON_TEXT = 'Quit BAON'
request_revert_backup = pyqtSignal()
request_delete_backup = pyqtSignal()
_main_window = None
_core = None
_progress_dialog = None
_core_thread = None
def __init__(self, args):
super().__init__(sys.argv)
# Actually we do quit when the last window is closed, but we need to do this in a more controlled way
self.setQuitOnLastWindowClosed(False)
self._init_threads()
self._init_main_objects(args)
self._connect_main_objects()
self._start_core()
def event(self, evt):
if isinstance(evt, QFileOpenEvent):
path = evt.file()
if not os.path.isdir(path):
path, _ = os.path.split(path)
self._main_window.set_base_path(path)
return True
return super().event(evt)
def _init_threads(self):
self._core_thread = QThread()
self._core_thread.start()
def _init_main_objects(self, args):
self._main_window = MainWindow(args)
self._core = BAONQtCore(args)
self._core.moveToThread(self._core_thread)
def _connect_main_objects(self):
self.aboutToQuit.connect(self._on_quit)
# Core vs. application
self._core.request_backup_decision.connect(self.backup_decision_requested)
self._core.reverted_backup.connect(self.notify_backup_reverted)
self._core.revert_backup_error.connect(self.handle_backup_op_error)
self._core.deleted_backup.connect(self.notify_backup_deleted)
self._core.delete_backup_error.connect(self.handle_backup_op_error)
self.request_revert_backup.connect(self._core.revert_backup)
self.request_delete_backup.connect(self._core.delete_backup)
# Core vs. main window
self._core.prologue_finished.connect(self._main_window.show_first_time)
self._core.status_changed.connect(self._main_window.report_status)
self._core.scanned_files_updated.connect(self._main_window.update_scanned_files)
self._core.renamed_files_updated.connect(self._main_window.update_renamed_files)
self._core.has_shutdown.connect(self.quit)
self._main_window.base_path_edited.connect(self._core.update_base_path)
self._main_window.scan_recursive_changed.connect(self._core.update_scan_recursive)
self._main_window.rules_text_changed.connect(self._core.update_rules_text)
self._main_window.use_path_changed.connect(self._core.update_use_path)
self._main_window.use_extension_changed.connect(self._core.update_use_extension)
self._main_window.request_add_override.connect(self._core.add_override)
self._main_window.request_remove_override.connect(self._core.remove_override)
self._main_window.request_do_rename.connect(self._core.do_rename)
self._main_window.request_rescan.connect(self._core.rescan)
self._main_window.rejected.connect(self._core.shutdown)
def _start_core(self):
QMetaObject.invokeMethod(self._core, 'start', Qt.QueuedConnection)
def _on_quit(self):
self._core_thread.quit()
self._core_thread.wait()
@pyqtSlot()
def backup_decision_requested(self):
self._show_backup_decision()
@pyqtSlot(Exception)
def handle_backup_op_error(self, error):
self._close_progress_dialog()
self._show_backup_decision(error=error)
@pyqtSlot()
def notify_backup_deleted(self):
QMessageBox.information(
None,
self.SUCCESS_DIALOG_CAPTION,
self.BACKUP_DELETED_DIALOG_TEXT,
)
@pyqtSlot(bool)
def notify_backup_reverted(self, complete_success):
self._close_progress_dialog()
if complete_success:
QMessageBox.information(
None,
self.SUCCESS_DIALOG_CAPTION,
self.BACKUP_REVERTED_SUCCESS_DIALOG_TEXT,
)
else:
QMessageBox.warning(
None,
self.WARNING_DIALOG_CAPTION,
self.BACKUP_REVERTED_WARNING_DIALOG_TEXT,
)
def _show_backup_decision(self, error=None):
text = '<p>{0}</p><p>{1}</p>'.format(
self.BACKUP_INTRO_TEXT if error is None else error,
self.BACKUP_PROMPT_TEXT,
)
dialog = QMessageBox(
QMessageBox.Question if error is None else QMessageBox.Critical,
self.BACKUP_DIALOG_CAPTION if error is None else self.BACKUP_DIALOG_ERROR_CAPTION,
text,
)
revert_button = dialog.addButton(self.REVERT_BACKUP_BUTTON_TEXT, QMessageBox.AcceptRole)
delete_button = dialog.addButton(self.DELETE_BACKUP_BUTTON_TEXT, QMessageBox.DestructiveRole)
examine_button = dialog.addButton(self.EXAMINE_BACKUP_BUTTON_TEXT, QMessageBox.ActionRole)
dialog.addButton(self.QUIT_BUTTON_TEXT, QMessageBox.RejectRole)
dialog.exec()
clicked_button = dialog.clickedButton()
if clicked_button == examine_button:
QMetaObject.invokeMethod(self, '_examine_backup', Qt.QueuedConnection)
elif clicked_button == revert_button:
self._progress_dialog = QProgressDialog(None)
self._progress_dialog.setLabelText(self.REVERT_BACKUP_PROGRESS_TEXT)
self._progress_dialog.setCancelButton(None)
self._progress_dialog.setRange(0, 0)
self._progress_dialog.forceShow()
self.request_revert_backup.emit()
elif clicked_button == delete_button:
self.request_delete_backup.emit()
else:
self.quit()
@pyqtSlot()
def _examine_backup(self):
error = None
try:
filename = get_rename_plan_backup_filename()
QDesktopServices.openUrl(QUrl.fromLocalFile(filename))
except Exception as err:
error = err
finally:
self._show_backup_decision(error)
def _close_progress_dialog(self):
if self._progress_dialog is not None:
self._progress_dialog.close()
self._progress_dialog = None