def create_progress_bar(self, title):
progress = QProgressDialog(self)
progress.setAutoClose(False)
progress.setWindowTitle(title)
progress.setCancelButton(None)
progress.setWindowModality(Qt.WindowModal)
return progress
def draw_progress_dialog(self):
d = QProgressDialog('Обработка битых ссылок', 'Отмена', 0, 0)
d.setWindowModality(Qt.WindowModal)
d.setCancelButton(None)
d.setWindowTitle('Обработка битых ссылок')
d.setMaximumWidth(500)
return d
def create_progress_bar(self, title):
progress = QProgressDialog(self)
progress.setAutoClose(False)
progress.setWindowTitle(title)
progress.setCancelButton(None)
progress.setWindowModality(Qt.WindowModal)
return progress
def stop_experiment(self, msg, stop_storing=False):
progress = QProgressDialog(None, Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
progress.setLabelText("Stopping...")
progress.setRange(0, 5)
progress.setCancelButton(None)
progress.show()
print("STOP EXPERIMENT!!!!")
uid = str(msg)
index = self.index_of(uid)
if index is None:
print("experiment uuid not found: ", uid)
return
exp = self.experiments[index]
if not exp.launcher_data:
print("this exp is not running...", uid)
return
if stop_storing:
# stop storing ONLY if the experiment was fired from this very obci gui
# otherwise the data is lost ....
# below code was to stop storing every time signal saver is in scenarios`es modules
# but it sometimes hangs forever eg. when we are using morph extensively ...
# `
# or ("signal_saver" in exp.exp_config.peers and\
# exp.status.peer_status("signal_saver").status_name \
# in [launcher_tools.RUNNING, launcher_tools.LAUNCHING]):
print("STOP STORING")
exp.stop_storing(self.client)
for i in range(4):
time.sleep(0.6) # FIXME - without it some problem with below kill...
progress.setValue(i + 1)
progress.setValue(5)
self._process_response(self.client.kill_exp(exp.uuid))
def save_scheme(self):
"""
Save scheme information, move supporting documents, save holders
table and create appropriate notifications.
"""
sch_number = None
pg_dlg = QProgressDialog(parent=self)
pg_dlg.setWindowModality(Qt.WindowModal)
pg_dlg.setMinimum(0)
pg_dlg.setMaximum(4)
pg_dlg.setCancelButton(None)
pg_dlg.setWindowTitle(self.tr('Saving Scheme Information...'))
pg_dlg.setLabelText(self.tr('Retrieving scheme attribute data...'))
pg_dlg.setValue(1)
# Get scheme db object for manual saving to database.
self.submit(True)
scheme_obj = self.model()
scheme_obj.plot_status = 2
QgsApplication.processEvents()
pg_dlg.setLabelText(
self.tr('Saving supporting documents, please wait...'))
pg_dlg.setValue(2)
# Format scheme number for saving in document repository
if not sch_number:
sch_number = scheme_obj.scheme_number.replace(" / ", "_")
sch_number = sch_number.replace(" ", "_")
# Attach documents
doc_objs = self._cmis_doc_mapper.persist_documents(sch_number)
scheme_obj.documents = doc_objs
QgsApplication.processEvents()
pg_dlg.setLabelText(self.tr('Saving scheme data...'))
pg_dlg.setValue(3)
scheme_obj.save()
# Update last value for generating scheme number
self._save_ra_last_value(scheme_obj.scheme_number)
QgsApplication.processEvents()
pg_dlg.setLabelText(self.tr('Saving holders data...'))
pg_dlg.setValue(4)
QgsApplication.processEvents()
# Attach the scheme object to the holders
self._holder_importer.set_extra_attribute_value(
'cb_scheme_collection', [scheme_obj])
# Save holders data
self._holder_importer.start()
QgsApplication.processEvents()
msg = self.tr(
u'A new scheme (No. {0}) has been successfully lodged.'.format(
scheme_obj.scheme_number))
QMessageBox.information(self, self.tr('New Scheme'), msg)
def write_data_to_file(self, open_mode):
progressDialog = QProgressDialog()
progressDialog.setModal(True)
progressDialog.setLabelText(self.tr('Guardando...'))
progressDialog.setMaximum(8)
progressDialog.setCancelButton(None)
progressDialog.show()
try:
# File is closed automatically even on error
with open(unicode(self.filename), open_mode) as file_obj:
for count, elem_edit in enumerate(self.lineEdits_list, 1):
file_obj.write(''.join([str(elem_edit[0].text()), '\n']))
file_obj.write(''.join([str(elem_edit[1].text()), '\n']))
file_obj.write(''.join([str(elem_edit[2].text()), '\n']))
file_obj.write(''.join([str(elem_edit[3].text()), '\n']))
file_obj.write(''.join([str(elem_edit[4].text()), '\n']))
file_obj.write(''.join([str(elem_edit[5].text()), '\n']))
file_obj.write(''.join([str(elem_edit[6].text()), '\n']))
file_obj.write(''.join([str(elem_edit[7].text()), '\n']))
file_obj.write(''.join([str(elem_edit[8].text()), '\n']))
file_obj.write(''.join([str(elem_edit[9].text()), '\n']))
file_obj.write(''.join([str(elem_edit[10].text()), '\n']))
file_obj.write(''.join([str(elem_edit[11].text()), '\n']))
progressDialog.setValue(count)
except (IOError, OSError):
progressDialog.close()
messageBox = QMessageBox(self)
messageBox.setStyleSheet(
'QMessageBox QLabel {font: bold 14pt "Cantarell";}')
messageBox.setWindowTitle(self.tr('Error'))
messageBox.setText(self.tr('Error al guardar'))
messageBox.setStandardButtons(QMessageBox.Ok)
messageBox.setIcon(QMessageBox.Critical)
messageBox.exec_()
else:
self.statusBar1.showMessage(self.tr('Guardado'), 3000)
class Progress:
def __init__(self, parent):
self.parent = parent
self.dialog = None
self.application = None
def started(self, title):
self.dialog = QProgressDialog(title, "Stop", 0, 0, self.parent)
self.dialog.setCancelButton(None)
self.dialog.show()
QCoreApplication.processEvents(QEventLoop.AllEvents)
def progress(self, msg, percent):
self.dialog.setLabelText(msg)
# otherwise KProgressDialog automatically closes itself, sigh
if percent < 100:
self.dialog.setValue(percent)
QCoreApplication.processEvents(QEventLoop.AllEvents)
def finished(self):
if self.dialog:
self.dialog.done(0)
self.dialog = None
class Progress:
def __init__(self, parent):
self.parent = parent
self.dialog = None
self.application = None
def started(self, title):
self.dialog = QProgressDialog(title, "Stop", 0, 0, self.parent)
self.dialog.setCancelButton(None)
self.dialog.show()
QCoreApplication.processEvents(QEventLoop.AllEvents)
def progress(self, msg, percent):
self.dialog.setLabelText(msg)
# otherwise KProgressDialog automatically closes itself, sigh
if percent < 100:
self.dialog.setValue(percent)
QCoreApplication.processEvents(QEventLoop.AllEvents)
def finished(self):
if self.dialog:
self.dialog.done(0)
self.dialog = None
class CSVGenerator:
def __init__(self,
left,
top,
right,
bottom,
csv_filename,
username,
password,
client_id,
client_secret,
days_to_query=60):
self.left = left
self.top = top
self.right = right
self.bottom = bottom
self.csv_filename = csv_filename
self.days_to_query = days_to_query
self.begin_date = None
self.end_date = None
self.username = username
self.password = password
self.client_id = client_id
self.client_secret = client_secret
# throw up a progress dialog
min_progress = 0.0
max_progress = ((self.right - self.left) / INCREMENTAL_INTERVAL) * \
((self.top - self.bottom) / INCREMENTAL_INTERVAL)
self.current_progress = min_progress
self.progress_dialog = QProgressDialog("Building up CSV file", "Abort",
int(min_progress),
int(max_progress), None)
self.progress_dialog.setCancelButton(None)
self.progress_dialog.setWindowTitle("CSV Output")
self.progress_dialog.setLabelText("Building up CSV file")
self.progress_dialog.setMinimumDuration(0)
self.progress_dialog.setValue(0)
self.progress_dialog.show()
self.csv_elements = []
self.csv_generator_object = CSVGeneratorObject(self)
self.vector_header_dict = {}
self.pool = QThreadPool()
self.finished_submissions = False
self.lock = Lock()
def generate_csv(self):
# dates
now = datetime.now()
self.end_date = now
self.begin_date = now - timedelta(days=self.days_to_query)
current_x = self.left
current_y = self.bottom
serial_no = 1
# get header dict
vector_query = VectorQuery(username=self.username,
password=self.password,
client_id=self.client_id,
client_secret=self.client_secret)
vector_query.log_in()
vector_params = InfoCubeVectorParams(top=self.top,
bottom=self.bottom,
left=self.left,
right=self.right,
time_begin=self.begin_date,
time_end=self.end_date)
header_result = vector_query.get_vector_result(vector_params)
self.vector_header_dict = vector_query.get_vector_data(header_result)
for next_x in drange(self.left + INCREMENTAL_INTERVAL, self.right,
INCREMENTAL_INTERVAL):
for next_y in drange(self.bottom + INCREMENTAL_INTERVAL, self.top,
INCREMENTAL_INTERVAL):
username = self.username
password = self.password
client_id = self.client_id
client_secret = self.client_secret
csv_runnable = CSVRunnable(username, password, client_id,
client_secret, serial_no, next_y,
current_x, next_x, current_y,
self.begin_date, self.end_date,
self.vector_header_dict)
csv_runnable.csv_object.new_csv_element.connect(
self.csv_generator_object.callback)
self.pool.start(csv_runnable)
serial_no += 1
current_y = next_y
current_y = self.bottom
current_x = next_x
self.finished_submissions = True
def on_completion(self):
self.csv_elements.sort(key=lambda element: element.serial_no)
log.info("Sort complete")
# write file
csv_file = open(self.csv_filename, 'w')
# write the header
header = CSVOutput.get_csv_header()
if self.vector_header_dict:
for term in self.vector_header_dict:
header = header + str(term) + ","
header = header[:-1]
csv_file.write(header)
csv_file.write("\n")
for csv_element in self.csv_elements:
csv_file.write(str(csv_element))
csv_file.write("\n")
csv_file.close()
log.info("Write complete")
if self.progress_dialog:
self.progress_dialog.close()
self.csv_generator_object.message_complete.emit(self.csv_filename)
def import_labeling_layer(labelLayer, labelingSlots, parent_widget=None):
"""
Prompt the user for layer import settings, and perform the layer import.
:param labelLayer: The top label layer source
:param labelingSlots: An instance of LabelingGui.LabelingSlots
:param parent_widget: The Qt GUI parent object
"""
writeSeeds = labelingSlots.labelInput
assert isinstance(
writeSeeds,
lazyflow.graph.Slot), "slot is of type %r" % (type(writeSeeds))
opLabels = writeSeeds.getRealOperator()
assert isinstance(opLabels, lazyflow.graph.Operator
), "slot's operator is of type %r" % (type(opLabels))
recentlyImported = PreferencesManager().get('labeling',
'recently imported')
mostRecentProjectPath = PreferencesManager().get('shell',
'recently opened')
mostRecentImageFile = PreferencesManager().get('DataSelection',
'recent image')
if recentlyImported:
defaultDirectory = os.path.split(recentlyImported)[0]
elif mostRecentProjectPath:
defaultDirectory = os.path.split(mostRecentProjectPath)[0]
elif mostRecentImageFile:
defaultDirectory = os.path.split(mostRecentImageFile)[0]
else:
defaultDirectory = os.path.expanduser('~')
fileNames = DataSelectionGui.getImageFileNamesToOpen(
parent_widget, defaultDirectory)
fileNames = map(str, fileNames)
if not fileNames:
return
PreferencesManager().set('labeling', 'recently imported', fileNames[0])
try:
# Initialize operators
opImport = OpInputDataReader(parent=opLabels.parent)
opCache = OpArrayCache(parent=opLabels.parent)
opMetadataInjector = OpMetadataInjector(parent=opLabels.parent)
opReorderAxes = OpReorderAxes(parent=opLabels.parent)
# Set up the pipeline as follows:
#
# opImport --> opCache --> opMetadataInjector --------> opReorderAxes --(inject via setInSlot)--> labelInput
# / /
# User-specified axisorder labelInput.meta.axistags
opImport.WorkingDirectory.setValue(defaultDirectory)
opImport.FilePath.setValue(fileNames[0] if len(fileNames) ==
1 else os.path.pathsep.join(fileNames))
assert opImport.Output.ready()
opCache.blockShape.setValue(opImport.Output.meta.shape)
opCache.Input.connect(opImport.Output)
assert opCache.Output.ready()
opMetadataInjector.Input.connect(opCache.Output)
metadata = opCache.Output.meta.copy()
opMetadataInjector.Metadata.setValue(metadata)
opReorderAxes.Input.connect(opMetadataInjector.Output)
# Transpose the axes for assignment to the labeling operator.
opReorderAxes.AxisOrder.setValue(writeSeeds.meta.getAxisKeys())
# We'll show a little window with a busy indicator while the data is loading
busy_dlg = QProgressDialog(parent=parent_widget)
busy_dlg.setLabelText("Importing Label Data...")
busy_dlg.setCancelButton(None)
busy_dlg.setMinimum(100)
busy_dlg.setMaximum(100)
def close_busy_dlg(*args):
QApplication.postEvent(busy_dlg, QCloseEvent())
# Load the data from file into our cache
# When it's done loading, close the progress dialog.
req = opCache.Output[:]
req.notify_finished(close_busy_dlg)
req.notify_failed(close_busy_dlg)
req.submit()
busy_dlg.exec_()
readData = req.result
maxLabels = len(labelingSlots.labelNames.value)
# Can't use return_counts feature because that requires numpy >= 1.9
#unique_read_labels, readLabelCounts = numpy.unique(readData, return_counts=True)
# This does the same as the above, albeit slower, and probably with more ram.
unique_read_labels = numpy.unique(readData)
readLabelCounts = numpy.bincount(readData.flat)[unique_read_labels]
labelInfo = (maxLabels, (unique_read_labels, readLabelCounts))
del readData
# Ask the user how to interpret the data.
settingsDlg = LabelImportOptionsDlg(parent_widget, fileNames,
opMetadataInjector.Output,
labelingSlots.labelInput,
labelInfo)
def handle_updated_axes():
# The user is specifying a new interpretation of the file's axes
updated_axisorder = str(settingsDlg.axesEdit.text())
metadata = opMetadataInjector.Metadata.value.copy()
metadata.axistags = vigra.defaultAxistags(updated_axisorder)
opMetadataInjector.Metadata.setValue(metadata)
settingsDlg.axesEdit.editingFinished.connect(handle_updated_axes)
dlg_result = settingsDlg.exec_()
if dlg_result != LabelImportOptionsDlg.Accepted:
return
# Get user's chosen label mapping from dlg
labelMapping = settingsDlg.labelMapping
# Get user's chosen offsets.
# Offsets in dlg only include the file axes, not the 5D axes expected by the label input,
# so expand them to full 5D
axes_5d = opReorderAxes.Output.meta.getAxisKeys()
tagged_offsets = collections.OrderedDict(
zip(axes_5d, [0] * len(axes_5d)))
tagged_offsets.update(
dict(
zip(opMetadataInjector.Output.meta.getAxisKeys(),
settingsDlg.imageOffsets)))
imageOffsets = tagged_offsets.values()
# Optimization if mapping is identity
if labelMapping.keys() == labelMapping.values():
labelMapping = None
# This will be fast (it's already cached)
label_data = opReorderAxes.Output[:].wait()
# Map input labels to output labels
if labelMapping:
# There are other ways to do a relabeling (e.g skimage.segmentation.relabel_sequential)
# But this supports potentially huge values of unique_read_labels (in the billions),
# without needing GB of RAM.
mapping_indexes = numpy.searchsorted(unique_read_labels,
label_data)
new_labels = numpy.array(
[labelMapping[x] for x in unique_read_labels])
label_data[:] = new_labels[mapping_indexes]
label_roi = numpy.array(roiFromShape(opReorderAxes.Output.meta.shape))
label_roi += imageOffsets
label_slice = roiToSlice(*label_roi)
writeSeeds[label_slice] = label_data
finally:
opReorderAxes.cleanUp()
opMetadataInjector.cleanUp()
opCache.cleanUp()
opImport.cleanUp()
def import_labeling_layer(labelLayer, labelingSlots, parent_widget=None):
"""
Prompt the user for layer import settings, and perform the layer import.
:param labelLayer: The top label layer source
:param labelingSlots: An instance of LabelingGui.LabelingSlots
:param parent_widget: The Qt GUI parent object
"""
writeSeeds = labelingSlots.labelInput
assert isinstance(writeSeeds, lazyflow.graph.Slot), "slot is of type %r" % (type(writeSeeds))
opLabels = writeSeeds.getRealOperator()
assert isinstance(opLabels, lazyflow.graph.Operator), "slot's operator is of type %r" % (type(opLabels))
recentlyImported = PreferencesManager().get('labeling', 'recently imported')
mostRecentProjectPath = PreferencesManager().get('shell', 'recently opened')
mostRecentImageFile = PreferencesManager().get( 'DataSelection', 'recent image' )
if recentlyImported:
defaultDirectory = os.path.split(recentlyImported)[0]
elif mostRecentProjectPath:
defaultDirectory = os.path.split(mostRecentProjectPath)[0]
elif mostRecentImageFile:
defaultDirectory = os.path.split(mostRecentImageFile)[0]
else:
defaultDirectory = os.path.expanduser('~')
fileNames = DataSelectionGui.getImageFileNamesToOpen(parent_widget, defaultDirectory)
fileNames = map(str, fileNames)
if not fileNames:
return
PreferencesManager().set('labeling', 'recently imported', fileNames[0])
try:
# Initialize operators
opImport = OpInputDataReader( parent=opLabels.parent )
opCache = OpArrayCache( parent=opLabels.parent )
opMetadataInjector = OpMetadataInjector( parent=opLabels.parent )
opReorderAxes = OpReorderAxes( parent=opLabels.parent )
# Set up the pipeline as follows:
#
# opImport --> opCache --> opMetadataInjector --------> opReorderAxes --(inject via setInSlot)--> labelInput
# / /
# User-specified axisorder labelInput.meta.axistags
opImport.WorkingDirectory.setValue(defaultDirectory)
opImport.FilePath.setValue(fileNames[0] if len(fileNames) == 1 else
os.path.pathsep.join(fileNames))
assert opImport.Output.ready()
opCache.blockShape.setValue( opImport.Output.meta.shape )
opCache.Input.connect( opImport.Output )
assert opCache.Output.ready()
opMetadataInjector.Input.connect( opCache.Output )
metadata = opCache.Output.meta.copy()
opMetadataInjector.Metadata.setValue( metadata )
opReorderAxes.Input.connect( opMetadataInjector.Output )
# Transpose the axes for assignment to the labeling operator.
opReorderAxes.AxisOrder.setValue( writeSeeds.meta.getAxisKeys() )
# We'll show a little window with a busy indicator while the data is loading
busy_dlg = QProgressDialog(parent=parent_widget)
busy_dlg.setLabelText("Importing Label Data...")
busy_dlg.setCancelButton(None)
busy_dlg.setMinimum(100)
busy_dlg.setMaximum(100)
def close_busy_dlg(*args):
QApplication.postEvent(busy_dlg, QCloseEvent())
# Load the data from file into our cache
# When it's done loading, close the progress dialog.
req = opCache.Output[:]
req.notify_finished( close_busy_dlg )
req.notify_failed( close_busy_dlg )
req.submit()
busy_dlg.exec_()
readData = req.result
maxLabels = len(labelingSlots.labelNames.value)
# Can't use return_counts feature because that requires numpy >= 1.9
#unique_read_labels, readLabelCounts = numpy.unique(readData, return_counts=True)
# This does the same as the above, albeit slower, and probably with more ram.
unique_read_labels = numpy.unique(readData)
readLabelCounts = vigra_bincount(readData)[unique_read_labels]
labelInfo = (maxLabels, (unique_read_labels, readLabelCounts))
del readData
# Ask the user how to interpret the data.
settingsDlg = LabelImportOptionsDlg( parent_widget,
fileNames, opMetadataInjector.Output,
labelingSlots.labelInput, labelInfo )
def handle_updated_axes():
# The user is specifying a new interpretation of the file's axes
updated_axisorder = str(settingsDlg.axesEdit.text())
metadata = opMetadataInjector.Metadata.value.copy()
metadata.axistags = vigra.defaultAxistags(updated_axisorder)
opMetadataInjector.Metadata.setValue( metadata )
if opReorderAxes._invalid_axes:
settingsDlg.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
# Red background
settingsDlg.axesEdit.setStyleSheet("QLineEdit { background: rgb(255, 128, 128);"
"selection-background-color: rgb(128, 128, 255); }")
settingsDlg.axesEdit.editingFinished.connect( handle_updated_axes )
# Initialize
handle_updated_axes()
dlg_result = settingsDlg.exec_()
if dlg_result != LabelImportOptionsDlg.Accepted:
return
# Get user's chosen label mapping from dlg
labelMapping = settingsDlg.labelMapping
# Get user's chosen offsets.
# Offsets in dlg only include the file axes, not the 5D axes expected by the label input,
# so expand them to full 5D
axes_5d = opReorderAxes.Output.meta.getAxisKeys()
tagged_offsets = collections.OrderedDict( zip( axes_5d, [0]*len(axes_5d) ) )
tagged_offsets.update( dict( zip( opMetadataInjector.Output.meta.getAxisKeys(), settingsDlg.imageOffsets ) ) )
imageOffsets = tagged_offsets.values()
# Optimization if mapping is identity
if labelMapping.keys() == labelMapping.values():
labelMapping = None
# This will be fast (it's already cached)
label_data = opReorderAxes.Output[:].wait()
# Map input labels to output labels
if labelMapping:
# There are other ways to do a relabeling (e.g skimage.segmentation.relabel_sequential)
# But this supports potentially huge values of unique_read_labels (in the billions),
# without needing GB of RAM.
mapping_indexes = numpy.searchsorted(unique_read_labels, label_data)
new_labels = numpy.array([labelMapping[x] for x in unique_read_labels])
label_data[:] = new_labels[mapping_indexes]
label_roi = numpy.array( roiFromShape(opReorderAxes.Output.meta.shape) )
label_roi += imageOffsets
label_slice = roiToSlice(*label_roi)
writeSeeds[label_slice] = label_data
finally:
opReorderAxes.cleanUp()
opMetadataInjector.cleanUp()
opCache.cleanUp()
opImport.cleanUp()
def import_labeling_layer(labelLayer, labelingSlots, parent_widget=None):
"""
Prompt the user for layer import settings, and perform the layer import.
:param labelLayer: The top label layer source
:param labelingSlots: An instance of LabelingGui.LabelingSlots
:param parent_widget: The Qt GUI parent object
"""
writeSeeds = labelingSlots.labelInput
assert isinstance(
writeSeeds,
lazyflow.graph.Slot), "slot is of type %r" % (type(writeSeeds))
opLabels = writeSeeds.getRealOperator()
assert isinstance(opLabels, lazyflow.graph.Operator
), "slot's operator is of type %r" % (type(opLabels))
recentlyImported = PreferencesManager().get('labeling',
'recently imported')
mostRecentProjectPath = PreferencesManager().get('shell',
'recently opened')
mostRecentImageFile = PreferencesManager().get('DataSelection',
'recent image')
if recentlyImported:
defaultDirectory = os.path.split(recentlyImported)[0]
elif mostRecentProjectPath:
defaultDirectory = os.path.split(mostRecentProjectPath)[0]
elif mostRecentImageFile:
defaultDirectory = os.path.split(mostRecentImageFile)[0]
else:
defaultDirectory = os.path.expanduser('~')
fileNames = DataSelectionGui.getImageFileNamesToOpen(
parent_widget, defaultDirectory)
fileNames = map(str, fileNames)
if not fileNames:
return
PreferencesManager().set('labeling', 'recently imported', fileNames[0])
try:
# Initialize operators
opImport = OpInputDataReader(parent=opLabels.parent)
opCache = OpBlockedArrayCache(parent=opLabels.parent)
opMetadataInjector = OpMetadataInjector(parent=opLabels.parent)
opReorderAxes = OpReorderAxes(parent=opLabels.parent)
# Set up the pipeline as follows:
#
# opImport --> (opCache) --> opMetadataInjector --------> opReorderAxes --(inject via setInSlot)--> labelInput
# / /
# User-specified axisorder labelInput.meta.axistags
opImport.WorkingDirectory.setValue(defaultDirectory)
opImport.FilePath.setValue(fileNames[0] if len(fileNames) ==
1 else os.path.pathsep.join(fileNames))
assert opImport.Output.ready()
maxLabels = len(labelingSlots.labelNames.value)
# We don't bother with counting the label pixels
# (and caching the data) if it's big (1 GB)
if numpy.prod(opImport.Output.meta.shape) > 1e9:
reading_slot = opImport.Output
# For huge data, we don't go through and search for the pixel values,
# because that takes an annoyingly long amount of time.
# Instead, we make the reasonable assumption that the input labels are already 1,2,3..N
# and we don't tell the user what the label pixel counts are.
unique_read_labels = numpy.array(range(maxLabels + 1))
readLabelCounts = numpy.array([-1] * (maxLabels + 1))
labelInfo = (maxLabels, (unique_read_labels, readLabelCounts))
else:
opCache.Input.connect(opImport.Output)
opCache.CompressionEnabled.setValue(True)
assert opCache.Output.ready()
reading_slot = opCache.Output
# We'll show a little window with a busy indicator while the data is loading
busy_dlg = QProgressDialog(parent=parent_widget)
busy_dlg.setLabelText("Scanning Label Data...")
busy_dlg.setCancelButton(None)
busy_dlg.setMinimum(100)
busy_dlg.setMaximum(100)
def close_busy_dlg(*args):
QApplication.postEvent(busy_dlg, QCloseEvent())
# Load the data from file into our cache
# When it's done loading, close the progress dialog.
req = reading_slot[:]
req.notify_finished(close_busy_dlg)
req.notify_failed(close_busy_dlg)
req.submit()
busy_dlg.exec_()
readData = req.result
# Can't use return_counts feature because that requires numpy >= 1.9
#unique_read_labels, readLabelCounts = numpy.unique(readData, return_counts=True)
# This does the same as the above, albeit slower, and probably with more ram.
bincounts = chunked_bincount(readData)
unique_read_labels = bincounts.nonzero()[0].astype(readData.dtype,
copy=False)
readLabelCounts = bincounts[unique_read_labels]
labelInfo = (maxLabels, (unique_read_labels, readLabelCounts))
del readData
opMetadataInjector.Input.connect(reading_slot)
metadata = reading_slot.meta.copy()
opMetadataInjector.Metadata.setValue(metadata)
opReorderAxes.Input.connect(opMetadataInjector.Output)
# Transpose the axes for assignment to the labeling operator.
opReorderAxes.AxisOrder.setValue(writeSeeds.meta.getAxisKeys())
# Ask the user how to interpret the data.
settingsDlg = LabelImportOptionsDlg(parent_widget, fileNames,
opMetadataInjector.Output,
labelingSlots.labelInput,
labelInfo)
def handle_updated_axes():
# The user is specifying a new interpretation of the file's axes
updated_axisorder = str(settingsDlg.axesEdit.text())
metadata = opMetadataInjector.Metadata.value.copy()
metadata.axistags = vigra.defaultAxistags(updated_axisorder)
opMetadataInjector.Metadata.setValue(metadata)
if opReorderAxes._invalid_axes:
settingsDlg.buttonBox.button(
QDialogButtonBox.Ok).setEnabled(False)
# Red background
settingsDlg.axesEdit.setStyleSheet(
"QLineEdit { background: rgb(255, 128, 128);"
"selection-background-color: rgb(128, 128, 255); }")
settingsDlg.axesEdit.editingFinished.connect(handle_updated_axes)
# Initialize
handle_updated_axes()
dlg_result = settingsDlg.exec_()
if dlg_result != LabelImportOptionsDlg.Accepted:
return
# Get user's chosen label mapping from dlg
labelMapping = settingsDlg.labelMapping
# Get user's chosen offsets, ordered by the 'write seeds' slot
axes_5d = opReorderAxes.Output.meta.getAxisKeys()
tagged_offsets = collections.OrderedDict(
zip(axes_5d, [0] * len(axes_5d)))
tagged_offsets.update(
dict(
zip(opReorderAxes.Output.meta.getAxisKeys(),
settingsDlg.imageOffsets)))
imageOffsets = tagged_offsets.values()
# Optimization if mapping is identity
if labelMapping.keys() == labelMapping.values():
labelMapping = None
# If the data was already cached, this will be fast.
label_data = opReorderAxes.Output[:].wait()
# Map input labels to output labels
if labelMapping:
# There are other ways to do a relabeling (e.g skimage.segmentation.relabel_sequential)
# But this supports potentially huge values of unique_read_labels (in the billions),
# without needing GB of RAM.
mapping_indexes = numpy.searchsorted(unique_read_labels,
label_data)
new_labels = numpy.array(
[labelMapping[x] for x in unique_read_labels])
label_data[:] = new_labels[mapping_indexes]
label_roi = numpy.array(roiFromShape(opReorderAxes.Output.meta.shape))
label_roi += imageOffsets
label_slice = roiToSlice(*label_roi)
writeSeeds[label_slice] = label_data
finally:
opReorderAxes.cleanUp()
opMetadataInjector.cleanUp()
opCache.cleanUp()
opImport.cleanUp()
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
class CSVGenerator:
def __init__(self, left, top, right, bottom, csv_filename, username, password, client_id, client_secret, days_to_query=60):
self.left = left
self.top = top
self.right = right
self.bottom = bottom
self.csv_filename = csv_filename
self.days_to_query = days_to_query
self.begin_date = None
self.end_date = None
self.username = username
self.password = password
self.client_id = client_id
self.client_secret = client_secret
# throw up a progress dialog
min_progress = 0.0
max_progress = ((self.right - self.left) / INCREMENTAL_INTERVAL) * \
((self.top - self.bottom) / INCREMENTAL_INTERVAL)
self.current_progress = min_progress
self.progress_dialog = QProgressDialog("Building up CSV file", "Abort", int(min_progress), int(max_progress),
None)
self.progress_dialog.setCancelButton(None)
self.progress_dialog.setWindowTitle("CSV Output")
self.progress_dialog.setLabelText("Building up CSV file")
self.progress_dialog.setMinimumDuration(0)
self.progress_dialog.setValue(0)
self.progress_dialog.show()
self.csv_elements = []
self.csv_generator_object = CSVGeneratorObject(self)
self.vector_header_dict = {}
self.pool = QThreadPool()
self.finished_submissions = False
self.lock = Lock()
def generate_csv(self):
# dates
now = datetime.now()
self.end_date = now
self.begin_date = now - timedelta(days=self.days_to_query)
current_x = self.left
current_y = self.bottom
serial_no = 1
# get header dict
vector_query = VectorQuery(username=self.username, password=self.password, client_id=self.client_id, client_secret=self.client_secret)
vector_query.log_in()
vector_params = InfoCubeVectorParams(top=self.top, bottom=self.bottom, left=self.left, right=self.right, time_begin=self.begin_date, time_end=self.end_date)
header_result = vector_query.get_vector_result(vector_params)
self.vector_header_dict = vector_query.get_vector_data(header_result)
for next_x in drange(self.left + INCREMENTAL_INTERVAL, self.right, INCREMENTAL_INTERVAL):
for next_y in drange(self.bottom + INCREMENTAL_INTERVAL, self.top, INCREMENTAL_INTERVAL):
username = self.username
password = self.password
client_id = self.client_id
client_secret = self.client_secret
csv_runnable = CSVRunnable(username, password, client_id, client_secret,
serial_no, next_y, current_x, next_x,
current_y, self.begin_date, self.end_date, self.vector_header_dict)
csv_runnable.csv_object.new_csv_element.connect(self.csv_generator_object.callback)
self.pool.start(csv_runnable)
serial_no += 1
current_y = next_y
current_y = self.bottom
current_x = next_x
self.finished_submissions = True
def on_completion(self):
self.csv_elements.sort(key=lambda element: element.serial_no)
log.info("Sort complete")
# write file
csv_file = open(self.csv_filename, 'w')
# write the header
header = CSVOutput.get_csv_header()
if self.vector_header_dict:
for term in self.vector_header_dict:
header = header + str(term) + ","
header = header[:-1]
csv_file.write(header)
csv_file.write("\n")
for csv_element in self.csv_elements:
csv_file.write(str(csv_element))
csv_file.write("\n")
csv_file.close()
log.info("Write complete")
if self.progress_dialog:
self.progress_dialog.close()
self.csv_generator_object.message_complete.emit(self.csv_filename)
class RebuildIndex(object):
"""
Tool class to rebuild the indexation
"""
def __init__(self, iface):
"""
Constructor
:param iface: interface
"""
self.__iface = iface
self.icon_path = ':/plugins/VDLTools/icons/rebuild_icon.png'
self.text = QCoreApplication.translate("VDLTools", "Rebuild Index")
self.killed = False
def start(self):
"""
To start the rebuild
"""
snap_util = self.__iface.mapCanvas().snappingUtils()
extent = self.__iface.mapCanvas().extent()
self.__progressDialog = QProgressDialog()
self.__progressDialog.setWindowTitle(
QCoreApplication.translate("VDLTools", "Rebuild Index..."))
self.__progressDialog.setLabelText(
QCoreApplication.translate("VDLTools",
"Percentage of indexed layers"))
progressBar = QProgressBar(self.__progressDialog)
progressBar.setTextVisible(True)
cancelButton = QPushButton()
cancelButton.setText(QCoreApplication.translate("VDLTools", "Cancel"))
cancelButton.clicked.connect(self.kill)
self.__progressDialog.setBar(progressBar)
self.__progressDialog.setCancelButton(cancelButton)
self.__progressDialog.setMinimumWidth(300)
self.__progressDialog.show()
lcs_list = snap_util.layers()
step = 0
self.killed = False
for lc in lcs_list:
if self.killed:
break
locator = snap_util.locatorForLayer(lc.layer)
if locator.extent() is not None:
txt = locator.extent().toString()
else:
txt = "None"
print("old extent : " + txt)
print("new extent : " + extent.toString())
locator.setExtent(extent)
if not locator.hasIndex():
locator.init()
else:
locator.rebuildIndex()
locator.setExtent(None)
progressBar.setValue(100 * step / len(lcs_list))
step += 1
self.__progressDialog.close()
def kill(self):
"""
To stop the rebuild at the end of the current working layer
"""
self.killed = True
def loadImages(self):
self.game.board.image = QImage(self.game.board.image)
names = self.game.board.territoryNames()
progress = QProgressDialog("Loading Board", "", 0, len(names))
progress.setCancelButton(None)
progress.setMinimumDuration(0)
for (i, name) in enumerate(names):
progress.setValue(i)
t = self.game.board.getTerritory(name)
t.image = QImage(t.image)
#generate region map
regionOverlay = QImage(self.imageSize(), QImage.Format_ARGB32_Premultiplied)
regionOverlay.fill(0)
painter = QPainter()
painter.begin(regionOverlay)
labels = []
for r in self.game.board.regions:
regionMask = QImage(self.imageSize(), QImage.Format_ARGB32_Premultiplied)
regionMask.fill(0)
p = QPainter()
p.begin(regionMask)
center = QPoint(0, 0)
for t in r.territories:
p.drawImage(0, 0, t.image)
center += QPoint(*t.center)
center /= len(r.territories)
p.end()
regionImage = QImage(self.imageSize(), QImage.Format_ARGB32_Premultiplied)
regionImage.fill(0)
p.begin(regionImage)
p.setCompositionMode(QPainter.CompositionMode_Source)
color = [randint(0, 255) for i in range(3)] + [200]
p.fillRect(regionImage.rect(), QColor(*color))
p.setCompositionMode(QPainter.CompositionMode_DestinationIn)
p.drawImage(0, 0, regionMask)
p.end()
painter.drawImage(0, 0, regionImage)
text = "%s: %d" % (r.name, r.bonus)
labels.append((center, text))
for l in labels:
(center, text) = l
height = painter.fontMetrics().height() + 8
width = painter.fontMetrics().width(text) + 8
painter.setPen(Qt.white)
painter.setBrush(QColor(0, 0, 0, 200))
textRect = QRect(0, 0, width, height)
textRect.moveCenter(center)
painter.drawRect(textRect)
painter.drawText(textRect, Qt.AlignCenter, text)
painter.end()
regionMap = self.game.board.image.copy()
painter.begin(regionMap)
painter.drawImage(0, 0, regionOverlay)
painter.end()
self.regionMap = QPixmap.fromImage(regionMap)
self.scaledRegionMap = self.regionMap
self.ownershipMap = QPixmap.fromImage(self.game.board.image)
self.scaledOwnershipMap = self.ownershipMap
troopCountMap = QImage(self.game.board.image.size(), QImage.Format_ARGB32_Premultiplied)
troopCountMap.fill(0)
self.troopCountMap = QPixmap.fromImage(troopCountMap)
self.scaledTroopCountMap = self.troopCountMap
