class ApplicationsDialog(QDialog):
"""Dialog for selection of installed system/user applications."""
def __init__(self, parent=None):
"""Dialog for selection of installed system/user applications."""
super(ApplicationsDialog, self).__init__(parent=parent)
# Widgets
self.label = QLabel()
self.label_browse = QLabel()
self.edit_filter = QLineEdit()
self.list = QListWidget()
self.button_browse = QPushButton(_('Browse...'))
self.button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = self.button_box.button(QDialogButtonBox.Ok)
self.button_cancel = self.button_box.button(QDialogButtonBox.Cancel)
# Widget setup
self.setWindowTitle(_('Applications'))
self.edit_filter.setPlaceholderText(_('Type to filter by name'))
self.list.setIconSize(QSize(16, 16)) # FIXME: Use metrics
# Layout
layout = QVBoxLayout()
layout.addWidget(self.label)
layout.addWidget(self.edit_filter)
layout.addWidget(self.list)
layout_browse = QHBoxLayout()
layout_browse.addWidget(self.button_browse)
layout_browse.addWidget(self.label_browse)
layout.addLayout(layout_browse)
layout.addSpacing(12) # FIXME: Use metrics
layout.addWidget(self.button_box)
self.setLayout(layout)
# Signals
self.edit_filter.textChanged.connect(self.filter)
self.button_browse.clicked.connect(lambda x: self.browse())
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
self.list.currentItemChanged.connect(self._refresh)
self._refresh()
self.setup()
def setup(self, applications=None):
"""Load installed applications."""
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.list.clear()
if applications is None:
apps = get_installed_applications()
else:
apps = applications
for app in sorted(apps, key=lambda x: x.lower()):
fpath = apps[app]
icon = get_application_icon(fpath)
item = QListWidgetItem(icon, app)
item.setToolTip(fpath)
item.fpath = fpath
self.list.addItem(item)
# FIXME: Use metrics
self.list.setMinimumWidth(self.list.sizeHintForColumn(0) + 24)
QApplication.restoreOverrideCursor()
self._refresh()
def _refresh(self):
"""Refresh the status of buttons on widget."""
self.button_ok.setEnabled(self.list.currentRow() != -1)
def browse(self, fpath=None):
"""Prompt user to select an application not found on the list."""
app = None
item = None
if sys.platform == 'darwin':
if fpath is None:
basedir = '/Applications/'
filters = _('Applications (*.app)')
title = _('Select application')
fpath, __ = getopenfilename(self, title, basedir, filters)
if fpath and fpath.endswith('.app') and os.path.isdir(fpath):
app = os.path.basename(fpath).split('.app')[0]
for row in range(self.list.count()):
item = self.list.item(row)
if app == item.text() and fpath == item.fpath:
break
else:
item = None
elif os.name == 'nt':
if fpath is None:
basedir = 'C:\\'
filters = _('Applications (*.exe *.bat *.com)')
title = _('Select application')
fpath, __ = getopenfilename(self, title, basedir, filters)
if fpath:
check_1 = fpath.endswith('.bat') and is_text_file(fpath)
check_2 = (fpath.endswith(('.exe', '.com'))
and not is_text_file(fpath))
if check_1 or check_2:
app = os.path.basename(fpath).capitalize().rsplit('.')[0]
for row in range(self.list.count()):
item = self.list.item(row)
if app == item.text() and fpath == item.fpath:
break
else:
item = None
else:
if fpath is None:
basedir = '/'
filters = _('Applications (*.desktop)')
title = _('Select application')
fpath, __ = getopenfilename(self, title, basedir, filters)
if fpath and fpath.endswith(('.desktop')) and is_text_file(fpath):
entry_data = parse_linux_desktop_entry(fpath)
app = entry_data['name']
for row in range(self.list.count()):
item = self.list.item(row)
if app == item.text() and fpath == item.fpath:
break
else:
item = None
if fpath:
if item:
self.list.setCurrentItem(item)
elif app:
icon = get_application_icon(fpath)
item = QListWidgetItem(icon, app)
item.fpath = fpath
self.list.addItem(item)
self.list.setCurrentItem(item)
self.list.setFocus()
self._refresh()
def filter(self, text):
"""Filter the list of applications based on text."""
text = self.edit_filter.text().lower().strip()
for row in range(self.list.count()):
item = self.list.item(row)
item.setHidden(text not in item.text().lower())
self._refresh()
def set_extension(self, extension):
"""Set the extension on the label of the dialog."""
self.label.setText(
_('Choose the application for files of type ') + extension)
@property
def application_path(self):
"""Return the selected application path to executable."""
item = self.list.currentItem()
path = item.fpath if item else ''
return path
@property
def application_name(self):
"""Return the selected application name."""
item = self.list.currentItem()
text = item.text() if item else ''
return text
class EditableList(QWidget):
"""
Editable list with label, add, delete and edit buttons.
"""
sig_item_edited = Signal(object)
sig_item_removed = Signal(object)
sig_item_selected = Signal()
def __init__(self,
title=None,
items_text=[],
duplicates=False,
normalize=True,
min_items=1,
confirm_remove=True,
regex=None,
tooltip=None):
super(EditableList, self).__init__()
self.duplicates = duplicates
self.items_text = items_text
self.normalize = normalize
self.min_items = min_items
self.confirm_remove = confirm_remove
# Widgets
self.label_title = QLabel(title)
self.button_add = QPushButton(qta.icon('fa.plus'), '')
self.button_remove = QPushButton(qta.icon('fa.minus'), '')
self.button_edit = QPushButton(qta.icon('fa.edit'), '')
self.list = QListWidget()
self.delegate = EditableListDelegate(regex=regex, tooltip=tooltip)
# Widget setup
self.list.setItemDelegate(self.delegate)
self.setMaximumHeight(self._height() * 4)
# Layout
label_buttons_layout = QHBoxLayout()
label_buttons_layout.addWidget(self.label_title, 0)
label_buttons_layout.addStretch()
label_buttons_layout.addWidget(self.button_add)
label_buttons_layout.addWidget(self.button_remove)
label_buttons_layout.addWidget(self.button_edit)
layout = QVBoxLayout()
layout.addLayout(label_buttons_layout)
layout.addWidget(self.list)
self.setLayout(layout)
# Signals
self.button_add.clicked.connect(self.add)
self.button_edit.clicked.connect(self.edit)
self.button_remove.clicked.connect(self.remove)
self.delegate.closeEditor.connect(self.check_value)
self.list.currentItemChanged.connect(self.refresh)
self.list.itemSelectionChanged.connect(self.sig_item_selected)
# Setup
self.setup()
# Expose list methods
self.clear = self.list.clear
self.currentItem = self.list.currentItem
self.setCurrentRow = self.list.setCurrentRow
self.currentRow = self.list.currentRow
self.item = self.list.item
self.count = self.list.count
def _height(self):
"""
Get the height for the row in the widget based on OS font metrics.
"""
return self.fontMetrics().height() * 2
def setup(self):
"""
Initial setup for populating items if any.
"""
# TODO: Check against regex and raise error accordingly!
new_items = []
for text in self.items_text:
if self.normalize:
text = text.lower()
new_items.append(text)
self.items_text = new_items
if not self.duplicates:
if len(set(self.items_text)) != len(self.items_text):
raise Exception('The list cannot contains duplicates.')
for item in self.items_text:
item = QListWidgetItem(item)
item.extra_data = None
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.add(item)
item.setSizeHint(QSize(item.sizeHint().width(), self._height()))
self.refresh()
def get_texts(self):
"""
Returns the list of texts in the list, excluding the ones under
edition.
"""
row = self.list.currentRow()
texts = []
for i in range(self.list.count()):
item = self.list.item(i)
if item:
text = item.text().lower() if self.normalize else item.text()
texts.append(text)
# Check for duplicates. But the entered text already is part of the
# items, so that needs to be removed to make the check
if texts and row != -1:
texts.pop(row)
return texts
def add(self, item=None):
"""
Return the text of all items in the list, except the current one being
edited.
"""
if item:
if item.text() in self.get_texts() and not self.duplicates:
raise Exception
else:
self.list.addItem(item)
else:
item = QListWidgetItem()
item.extra_data = None
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsEditable)
self.list.addItem(item)
self.list.setCurrentItem(item)
item.setSizeHint(QSize(item.sizeHint().width(), self._height()))
self.edit()
self.refresh()
def remove(self):
"""
Remove item fron the list.
"""
row = self.list.currentRow()
item = self.list.currentItem()
if item is None:
self.refresh()
else:
text = item.text()
if self.confirm_remove:
message = ("Are you sure you want to remove<br>"
"<strong>{0}</strong>?".format(text))
reply = QMessageBox.question(self, 'Remove item', message,
QMessageBox.Yes, QMessageBox.No)
remove_item = reply == QMessageBox.Yes
else:
remove_item = True
if row != -1 and remove_item:
item = self.list.takeItem(row)
self.sig_item_removed.emit(item)
self.refresh()
def edit(self):
"""
Start editing item from the list.
"""
self.button_remove.setDisabled(True)
self.button_add.setDisabled(True)
self.button_edit.setDisabled(True)
item = self.current_item()
if item:
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsEditable)
item._text = item.text()
self.list.editItem(item)
def current_item(self):
"""
Return the current selected item.
"""
item = None
row = self.list.currentRow()
if row != -1:
item = self.list.item(row)
return item
def check_value(self):
"""
After editing an item check the value is valid and return to edit mode
if it does not pass, or accept the value and add it.
"""
texts = self.get_texts()
item = self.current_item()
self._temp_item = item
if item:
text = item.text().lower() if self.normalize else item.text()
row = self.list.currentRow()
if text.strip() == '':
self.list.takeItem(row)
if text.strip() in texts and not self.duplicates:
self.edit()
else:
self.sig_item_edited.emit(item)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
def refresh(self):
"""
Refresh the enabled status of the actions buttons.
"""
current_row = self.list.currentRow()
if self.list.count() == 0:
self.button_edit.setDisabled(True)
self.button_remove.setDisabled(True)
elif self.list.count() != 0 and current_row == -1:
self.button_edit.setDisabled(True)
self.button_remove.setDisabled(True)
elif self.list.count() == self.min_items:
self.button_add.setDisabled(False)
self.button_edit.setDisabled(False)
self.button_remove.setDisabled(True)
elif self.list.count() != 0 and current_row != -1:
self.button_add.setDisabled(False)
self.button_edit.setDisabled(False)
self.button_remove.setDisabled(False)
for i in range(self.list.count()):
item = self.list.item(i)
item.setSizeHint(QSize(item.sizeHint().width(), self._height()))
class FileAssociationsWidget(QWidget):
"""Widget to add applications association to file extensions."""
# This allows validating a single extension entry or a list of comma
# separated values (eg `*.json` or `*.json,*.txt,MANIFEST.in`)
_EXTENSIONS_LIST_REGEX = (r'(?:(?:\*{1,1}|\w+)\.\w+)'
r'(?:,(?:\*{1,1}|\w+)\.\w+){0,20}')
sig_data_changed = Signal(dict)
def __init__(self, parent=None):
"""Widget to add applications association to file extensions."""
super(FileAssociationsWidget, self).__init__(parent=parent)
# Variables
self._data = {}
self._dlg_applications = None
self._dlg_input = None
self._regex = re.compile(self._EXTENSIONS_LIST_REGEX)
# Widgets
self.label = QLabel(
_('Here you can associate which external applications you want'
'to use to open specific file extensions <br> (e.g. .txt '
'files with Notepad++ or .csv files with Excel).'))
self.label_extensions = QLabel(_('File types:'))
self.list_extensions = QListWidget()
self.button_add = QPushButton(_('Add'))
self.button_remove = QPushButton(_('Remove'))
self.button_edit = QPushButton(_('Edit'))
self.label_applications = QLabel(_('Associated applications:'))
self.list_applications = QListWidget()
self.button_add_application = QPushButton(_('Add'))
self.button_remove_application = QPushButton(_('Remove'))
self.button_default = QPushButton(_('Set default'))
# Layout
layout_extensions = QHBoxLayout()
layout_extensions.addWidget(self.list_extensions, 4)
layout_buttons_extensions = QVBoxLayout()
layout_buttons_extensions.addWidget(self.button_add)
layout_buttons_extensions.addWidget(self.button_remove)
layout_buttons_extensions.addWidget(self.button_edit)
layout_buttons_extensions.addStretch()
layout_applications = QHBoxLayout()
layout_applications.addWidget(self.list_applications, 4)
layout_buttons_applications = QVBoxLayout()
layout_buttons_applications.addWidget(self.button_add_application)
layout_buttons_applications.addWidget(self.button_remove_application)
layout_buttons_applications.addWidget(self.button_default)
layout_buttons_applications.addStretch()
layout_extensions.addLayout(layout_buttons_extensions, 2)
layout_applications.addLayout(layout_buttons_applications, 2)
layout = QVBoxLayout()
layout.addWidget(self.label)
layout.addWidget(self.label_extensions)
layout.addLayout(layout_extensions)
layout.addWidget(self.label_applications)
layout.addLayout(layout_applications)
self.setLayout(layout)
# Signals
self.button_add.clicked.connect(lambda: self.add_association())
self.button_remove.clicked.connect(self.remove_association)
self.button_edit.clicked.connect(self.edit_association)
self.button_add_application.clicked.connect(self.add_application)
self.button_remove_application.clicked.connect(self.remove_application)
self.button_default.clicked.connect(self.set_default_application)
self.list_extensions.currentRowChanged.connect(self.update_extensions)
self.list_extensions.itemDoubleClicked.connect(self.edit_association)
self.list_applications.currentRowChanged.connect(
self.update_applications)
self._refresh()
self._create_association_dialog()
def _refresh(self):
"""Refresh the status of buttons on widget."""
self.setUpdatesEnabled(False)
for widget in [
self.button_remove, self.button_add_application,
self.button_edit, self.button_remove_application,
self.button_default
]:
widget.setDisabled(True)
item = self.list_extensions.currentItem()
if item:
for widget in [
self.button_remove, self.button_add_application,
self.button_remove_application, self.button_edit
]:
widget.setDisabled(False)
self.update_applications()
self.setUpdatesEnabled(True)
def _add_association(self, value):
"""Add association helper."""
# Check value is not pressent
for row in range(self.list_extensions.count()):
item = self.list_extensions.item(row)
if item.text().strip() == value.strip():
break
else:
item = QListWidgetItem(value)
self.list_extensions.addItem(item)
self.list_extensions.setCurrentItem(item)
self._refresh()
def _add_application(self, app_name, fpath):
"""Add application helper."""
app_not_found_text = _(' (Application not found!)')
for row in range(self.list_applications.count()):
item = self.list_applications.item(row)
# Ensure the actual name is checked without the `app not found`
# additional text, in case app was not found
item_text = item.text().replace(app_not_found_text, '').strip()
if item and item_text == app_name:
break
else:
icon = get_application_icon(fpath)
if not (os.path.isfile(fpath) or os.path.isdir(fpath)):
app_name += app_not_found_text
item = QListWidgetItem(icon, app_name)
self.list_applications.addItem(item)
self.list_applications.setCurrentItem(item)
if not (os.path.isfile(fpath) or os.path.isdir(fpath)):
item.setToolTip(_('Application not found!'))
def _update_extensions(self):
"""Update extensions list."""
self.list_extensions.clear()
for extension, _ in sorted(self._data.items()):
self._add_association(extension)
# Select first item
self.list_extensions.setCurrentRow(0)
self.update_extensions()
self.update_applications()
def _create_association_dialog(self):
"""Create input extension dialog and save it to for reuse."""
self._dlg_input = InputTextDialog(
self,
title=_('File association'),
label=(_('Enter new file extension. You can add several values '
'separated by commas.<br>Examples include:') +
'<ul><li><code>*.txt</code></li>' +
'<li><code>*.json,*,csv</code></li>' +
'<li><code>*.json,README.md</code></li></ul>'),
)
self._dlg_input.set_regex_validation(self._EXTENSIONS_LIST_REGEX)
def load_values(self, data=None):
"""
Load file associations data.
Format {'*.ext': [['Application Name', '/path/to/app/executable']]}
`/path/to/app/executable` is an executable app on mac and windows and
a .desktop xdg file on linux.
"""
self._data = data
self._update_extensions()
def add_association(self, value=None):
"""Add extension file association."""
if value is None:
text, ok_pressed = '', False
self._dlg_input.set_text('')
if self._dlg_input.exec_():
text = self._dlg_input.text()
ok_pressed = True
else:
match = self._regex.match(value)
text, ok_pressed = value, bool(match)
if ok_pressed:
if text not in self._data:
self._data[text] = []
self._add_association(text)
self.check_data_changed()
def remove_association(self):
"""Remove extension file association."""
if self._data:
if self.current_extension:
self._data.pop(self.current_extension)
self._update_extensions()
self._refresh()
self.check_data_changed()
def edit_association(self):
"""Edit text of current selected association."""
old_text = self.current_extension
self._dlg_input.set_text(old_text)
if self._dlg_input.exec_():
new_text = self._dlg_input.text()
if old_text != new_text:
values = self._data.pop(self.current_extension)
self._data[new_text] = values
self._update_extensions()
self._refresh()
for row in range(self.list_extensions.count()):
item = self.list_extensions.item(row)
if item.text() == new_text:
self.list_extensions.setCurrentItem(item)
break
self.check_data_changed()
def add_application(self):
"""Remove application to selected extension."""
if self.current_extension:
if self._dlg_applications is None:
self._dlg_applications = ApplicationsDialog(self)
self._dlg_applications.set_extension(self.current_extension)
if self._dlg_applications.exec_():
app_name = self._dlg_applications.application_name
fpath = self._dlg_applications.application_path
self._data[self.current_extension].append((app_name, fpath))
self._add_application(app_name, fpath)
self.check_data_changed()
def remove_application(self):
"""Remove application from selected extension."""
current_row = self.list_applications.currentRow()
values = self._data.get(self.current_extension)
if values and current_row != -1:
values.pop(current_row)
self.update_extensions()
self.update_applications()
self.check_data_changed()
def set_default_application(self):
"""
Set the selected item on the application list as default application.
"""
current_row = self.list_applications.currentRow()
if current_row != -1:
values = self._data[self.current_extension]
value = values.pop(current_row)
values.insert(0, value)
self._data[self.current_extension] = values
self.update_extensions()
self.check_data_changed()
def update_extensions(self, row=None):
"""Update extensiosn list after additions or deletions."""
self.list_applications.clear()
for extension, values in self._data.items():
if extension.strip() == self.current_extension:
for (app_name, fpath) in values:
self._add_application(app_name, fpath)
break
self.list_applications.setCurrentRow(0)
self._refresh()
def update_applications(self, row=None):
"""Update application list after additions or deletions."""
current_row = self.list_applications.currentRow()
self.button_default.setEnabled(current_row != 0)
def check_data_changed(self):
"""Check if data has changed and emit signal as needed."""
self.sig_data_changed.emit(self._data)
@property
def current_extension(self):
"""Return the current selected extension text."""
item = self.list_extensions.currentItem()
if item:
return item.text()
@property
def data(self):
"""Return the current file associations data."""
return self._data.copy()
class CreatePlan(QWidget):
plan_created = Signal()
plan_node_changed = Signal()
def __init__(self, settings: PartSettings):
super().__init__()
self.settings = settings
self.save_translate_dict: typing.Dict[str, SaveBase] = {
x.get_short_name(): x
for x in save_dict.values()
}
self.plan = PlanPreview(self)
self.save_plan_btn = QPushButton("Save")
self.clean_plan_btn = QPushButton("Remove all")
self.remove_btn = QPushButton("Remove")
self.update_element_chk = QCheckBox("Update element")
self.change_root = EnumComboBox(RootType)
self.save_choose = QComboBox()
self.save_choose.addItem("<none>")
self.save_choose.addItems(list(self.save_translate_dict.keys()))
self.save_btn = QPushButton("Save")
self.segment_profile = QListWidget()
self.pipeline_profile = QListWidget()
self.segment_stack = QTabWidget()
self.segment_stack.addTab(self.segment_profile, "Profile")
self.segment_stack.addTab(self.pipeline_profile, "Pipeline")
self.generate_mask_btn = QPushButton("Add mask")
self.generate_mask_btn.setToolTip("Mask need to have unique name")
self.mask_name = QLineEdit()
self.mask_operation = EnumComboBox(MaskOperation)
self.chanel_num = QSpinBox()
self.choose_channel_for_measurements = QComboBox()
self.choose_channel_for_measurements.addItems(
["Same as segmentation"] +
[str(x + 1) for x in range(MAX_CHANNEL_NUM)])
self.units_choose = EnumComboBox(Units)
self.units_choose.set_value(self.settings.get("units_value", Units.nm))
self.chanel_num.setRange(0, 10)
self.expected_node_type = None
self.save_constructor = None
self.chose_profile_btn = QPushButton("Add Profile")
self.get_big_btn = QPushButton("Leave the biggest")
self.get_big_btn.hide()
self.add_new_segmentation_btn = QPushButton("Add new profile")
self.get_big_btn.setDisabled(True)
self.add_new_segmentation_btn.setDisabled(True)
self.measurements_list = QListWidget(self)
self.measurement_name_prefix = QLineEdit(self)
self.add_calculation_btn = QPushButton("Add measurement calculation")
self.information = QTextEdit()
self.information.setReadOnly(True)
self.protect = False
self.mask_set = set()
self.calculation_plan = CalculationPlan()
self.plan.set_plan(self.calculation_plan)
self.segmentation_mask = MaskWidget(settings)
self.file_mask = FileMask()
self.change_root.currentIndexChanged.connect(self.change_root_type)
self.save_choose.currentTextChanged.connect(self.save_changed)
self.measurements_list.currentTextChanged.connect(
self.show_measurement)
self.segment_profile.currentTextChanged.connect(self.show_segment)
self.measurements_list.currentTextChanged.connect(
self.show_measurement_info)
self.segment_profile.currentTextChanged.connect(self.show_segment_info)
self.pipeline_profile.currentTextChanged.connect(
self.show_segment_info)
self.pipeline_profile.currentTextChanged.connect(self.show_segment)
self.mask_name.textChanged.connect(self.mask_name_changed)
self.generate_mask_btn.clicked.connect(self.create_mask)
self.clean_plan_btn.clicked.connect(self.clean_plan)
self.remove_btn.clicked.connect(self.remove_element)
self.mask_name.textChanged.connect(self.mask_text_changed)
self.chose_profile_btn.clicked.connect(self.add_segmentation)
self.get_big_btn.clicked.connect(self.add_leave_biggest)
self.add_calculation_btn.clicked.connect(self.add_measurement)
self.save_plan_btn.clicked.connect(self.add_calculation_plan)
# self.forgot_mask_btn.clicked.connect(self.forgot_mask)
# self.cmap_save_btn.clicked.connect(self.save_to_cmap)
self.save_btn.clicked.connect(self.add_save_to_project)
self.update_element_chk.stateChanged.connect(self.mask_text_changed)
self.update_element_chk.stateChanged.connect(self.show_measurement)
self.update_element_chk.stateChanged.connect(self.show_segment)
self.update_element_chk.stateChanged.connect(self.update_names)
self.segment_stack.currentChanged.connect(
self.change_segmentation_table)
plan_box = QGroupBox("Prepare workflow:")
lay = QVBoxLayout()
lay.addWidget(self.plan)
bt_lay = QGridLayout()
bt_lay.setSpacing(0)
bt_lay.addWidget(self.save_plan_btn, 0, 0)
bt_lay.addWidget(self.clean_plan_btn, 0, 1)
bt_lay.addWidget(self.remove_btn, 1, 0)
bt_lay.addWidget(self.update_element_chk, 1, 1)
lay.addLayout(bt_lay)
plan_box.setLayout(lay)
plan_box.setStyleSheet(group_sheet)
other_box = QGroupBox("Other operations:")
other_box.setContentsMargins(0, 0, 0, 0)
bt_lay = QVBoxLayout()
bt_lay.setSpacing(0)
bt_lay.addWidget(QLabel("Root type:"))
bt_lay.addWidget(self.change_root)
bt_lay.addStretch(1)
bt_lay.addWidget(QLabel("Saving:"))
bt_lay.addWidget(self.save_choose)
bt_lay.addWidget(self.save_btn)
other_box.setLayout(bt_lay)
other_box.setStyleSheet(group_sheet)
mask_box = QGroupBox("Use mask from:")
mask_box.setStyleSheet(group_sheet)
self.mask_stack = QTabWidget()
self.mask_stack.addTab(stretch_widget(self.file_mask), "File")
self.mask_stack.addTab(stretch_widget(self.segmentation_mask),
"Current segmentation")
self.mask_stack.addTab(stretch_widget(self.mask_operation),
"Operations on masks")
self.mask_stack.setTabToolTip(
2,
"Allows to create mask which is based on masks previously added to plan."
)
lay = QGridLayout()
lay.setSpacing(0)
lay.addWidget(self.mask_stack, 0, 0, 1, 2)
label = QLabel("Mask name:")
label.setToolTip(
"Needed if you would like to reuse this mask in tab 'Operations on masks'"
)
self.mask_name.setToolTip(
"Needed if you would like to reuse this mask in tab 'Operations on masks'"
)
lay.addWidget(label, 1, 0)
lay.addWidget(self.mask_name, 1, 1)
lay.addWidget(self.generate_mask_btn, 2, 0, 1, 2)
mask_box.setLayout(lay)
segment_box = QGroupBox("Segmentation:")
segment_box.setStyleSheet(group_sheet)
lay = QVBoxLayout()
lay.setSpacing(0)
lay.addWidget(self.segment_stack)
lay.addWidget(self.chose_profile_btn)
lay.addWidget(self.get_big_btn)
lay.addWidget(self.add_new_segmentation_btn)
segment_box.setLayout(lay)
measurement_box = QGroupBox("Set of measurements:")
measurement_box.setStyleSheet(group_sheet)
lay = QGridLayout()
lay.setSpacing(0)
lay.addWidget(self.measurements_list, 0, 0, 1, 2)
lab = QLabel("Name prefix:")
lab.setToolTip("Prefix added before each column name")
lay.addWidget(lab, 1, 0)
lay.addWidget(self.measurement_name_prefix, 1, 1)
lay.addWidget(QLabel("Channel:"), 2, 0)
lay.addWidget(self.choose_channel_for_measurements, 2, 1)
lay.addWidget(QLabel("Units:"))
lay.addWidget(self.units_choose, 3, 1)
lay.addWidget(self.add_calculation_btn, 4, 0, 1, 2)
measurement_box.setLayout(lay)
info_box = QGroupBox("Information")
info_box.setStyleSheet(group_sheet)
lay = QVBoxLayout()
lay.addWidget(self.information)
info_box.setLayout(lay)
layout = QGridLayout()
fst_col = QVBoxLayout()
fst_col.addWidget(plan_box, 1)
fst_col.addWidget(mask_box)
layout.addWidget(plan_box, 0, 0, 5, 1)
# layout.addWidget(plan_box, 0, 0, 3, 1)
# layout.addWidget(mask_box, 3, 0, 2, 1)
# layout.addWidget(segmentation_mask_box, 1, 1)
layout.addWidget(mask_box, 0, 2, 1, 2)
layout.addWidget(other_box, 0, 1)
layout.addWidget(segment_box, 1, 1, 1, 2)
layout.addWidget(measurement_box, 1, 3)
layout.addWidget(info_box, 3, 1, 1, 3)
self.setLayout(layout)
self.generate_mask_btn.setDisabled(True)
self.chose_profile_btn.setDisabled(True)
self.add_calculation_btn.setDisabled(True)
self.mask_allow = False
self.segment_allow = False
self.file_mask_allow = False
self.node_type = NodeType.root
self.node_name = ""
self.plan_node_changed.connect(self.mask_text_changed)
self.plan.changed_node.connect(self.node_type_changed)
self.plan_node_changed.connect(self.show_segment)
self.plan_node_changed.connect(self.show_measurement)
self.plan_node_changed.connect(self.mask_stack_change)
self.mask_stack.currentChanged.connect(self.mask_stack_change)
self.file_mask.value_changed.connect(self.mask_stack_change)
self.mask_name.textChanged.connect(self.mask_stack_change)
self.node_type_changed()
def change_root_type(self):
value: RootType = self.change_root.get_value()
self.calculation_plan.set_root_type(value)
self.plan.update_view()
def change_segmentation_table(self):
index = self.segment_stack.currentIndex()
text = self.segment_stack.tabText(index)
if self.update_element_chk.isChecked():
self.chose_profile_btn.setText("Replace " + text)
else:
self.chose_profile_btn.setText("Add " + text)
self.segment_profile.setCurrentItem(None)
self.pipeline_profile.setCurrentItem(None)
def save_changed(self, text):
text = str(text)
if text == "<none>":
self.save_btn.setText("Save")
self.save_btn.setToolTip("Choose file type")
self.expected_node_type = None
self.save_constructor = None
else:
save_class = self.save_translate_dict.get(text, None)
if save_class is None:
self.save_choose.setCurrentText("<none>")
return
self.save_btn.setText(f"Save to {save_class.get_short_name()}")
self.save_btn.setToolTip("Choose mask create in plan view")
if save_class.need_mask():
self.expected_node_type = NodeType.mask
elif save_class.need_segmentation():
self.expected_node_type = NodeType.segment
else:
self.expected_node_type = NodeType.root
self.save_constructor = Save
self.save_activate()
def save_activate(self):
self.save_btn.setDisabled(True)
if self.node_type == self.expected_node_type:
self.save_btn.setEnabled(True)
return
def segmentation_from_project(self):
self.calculation_plan.add_step(Operations.reset_to_base)
self.plan.update_view()
def update_names(self):
if self.update_element_chk.isChecked():
self.chose_profile_btn.setText("Replace Profile")
self.add_calculation_btn.setText("Replace set of measurements")
self.generate_mask_btn.setText("Replace mask")
else:
self.chose_profile_btn.setText("Add Profile")
self.add_calculation_btn.setText("Add set of measurements")
self.generate_mask_btn.setText("Generate mask")
def node_type_changed(self):
# self.cmap_save_btn.setDisabled(True)
self.save_btn.setDisabled(True)
self.node_name = ""
if self.plan.currentItem() is None:
self.mask_allow = False
self.file_mask_allow = False
self.segment_allow = False
self.remove_btn.setDisabled(True)
self.plan_node_changed.emit()
logging.debug("[node_type_changed] return")
return
node_type = self.calculation_plan.get_node_type()
self.node_type = node_type
if node_type in [
NodeType.file_mask, NodeType.mask, NodeType.segment,
NodeType.measurement, NodeType.save
]:
self.remove_btn.setEnabled(True)
else:
self.remove_btn.setEnabled(False)
if node_type == NodeType.mask or node_type == NodeType.file_mask:
self.mask_allow = False
self.segment_allow = True
self.file_mask_allow = False
self.node_name = self.calculation_plan.get_node().operation.name
elif node_type == NodeType.segment:
self.mask_allow = True
self.segment_allow = False
self.file_mask_allow = False
self.save_btn.setEnabled(True)
# self.cmap_save_btn.setEnabled(True)
elif node_type == NodeType.root:
self.mask_allow = False
self.segment_allow = True
self.file_mask_allow = True
elif node_type == NodeType.none or node_type == NodeType.measurement or node_type == NodeType.save:
self.mask_allow = False
self.segment_allow = False
self.file_mask_allow = False
self.save_activate()
self.plan_node_changed.emit()
def add_save_to_project(self):
save_class = self.save_translate_dict.get(
self.save_choose.currentText(), None)
if save_class is None:
QMessageBox.warning(self, "Save problem", "Not found save class")
dial = FormDialog([
AlgorithmProperty("suffix", "File suffix", ""),
AlgorithmProperty("directory", "Sub directory", "")
] + save_class.get_fields())
if dial.exec():
values = dial.get_values()
suffix = values["suffix"]
directory = values["directory"]
del values["suffix"]
del values["directory"]
save_elem = Save(suffix, directory, save_class.get_name(),
save_class.get_short_name(), values)
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(save_elem)
else:
self.calculation_plan.add_step(save_elem)
self.plan.update_view()
def create_mask(self):
text = str(self.mask_name.text()).strip()
if text != "" and text in self.mask_set:
QMessageBox.warning(self, "Already exists",
"Mask with this name already exists",
QMessageBox.Ok)
return
if _check_widget(self.mask_stack, EnumComboBox): # existing mask
mask_dialog = TwoMaskDialog
if self.mask_operation.get_value(
) == MaskOperation.mask_intersection: # Mask intersection
MaskConstruct = MaskIntersection
else:
MaskConstruct = MaskSum
dial = mask_dialog(self.mask_set)
if not dial.exec():
return
names = dial.get_result()
mask_ob = MaskConstruct(text, *names)
elif _check_widget(self.mask_stack, MaskWidget):
mask_ob = MaskCreate(text,
self.segmentation_mask.get_mask_property())
elif _check_widget(self.mask_stack, FileMask):
mask_ob = self.file_mask.get_value(text)
else:
raise ValueError("Unknowsn widget")
if self.update_element_chk.isChecked():
node = self.calculation_plan.get_node()
name = node.operation.name
if name in self.calculation_plan.get_reused_mask(
) and name != text:
QMessageBox.warning(
self, "Cannot remove",
f"Cannot remove mask '{name}' from plan because it is used in other elements"
)
return
self.mask_set.remove(name)
self.mask_set.add(mask_ob.name)
self.calculation_plan.replace_step(mask_ob)
else:
self.mask_set.add(mask_ob.name)
self.calculation_plan.add_step(mask_ob)
self.plan.update_view()
self.mask_text_changed()
def mask_stack_change(self):
node_type = self.calculation_plan.get_node_type()
if self.update_element_chk.isChecked() and node_type not in [
NodeType.mask, NodeType.file_mask
]:
self.generate_mask_btn.setDisabled(True)
text = self.mask_name.text()
update = self.update_element_chk.isChecked()
if self.node_type == NodeType.none:
self.generate_mask_btn.setDisabled(True)
return
operation = self.calculation_plan.get_node().operation
if (not update and isinstance(operation, (MaskMapper, MaskBase))
and self.calculation_plan.get_node().operation.name == text):
self.generate_mask_btn.setDisabled(True)
return
if _check_widget(self.mask_stack, EnumComboBox): # reuse mask
if len(self.mask_set) > 1 and (
(not update and node_type == NodeType.root) or
(update and node_type == NodeType.file_mask)):
self.generate_mask_btn.setEnabled(True)
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip(
"Need at least two named mask and root selected")
elif _check_widget(self.mask_stack,
MaskWidget): # mask from segmentation
if (not update and node_type == NodeType.segment) or (
update and node_type == NodeType.mask):
self.generate_mask_btn.setEnabled(True)
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip("Select segmentation")
else:
if (not update and node_type == NodeType.root) or (
update and node_type == NodeType.file_mask):
self.generate_mask_btn.setEnabled(self.file_mask.is_valid())
else:
self.generate_mask_btn.setEnabled(False)
self.generate_mask_btn.setToolTip("Need root selected")
def mask_name_changed(self, text):
if str(text) in self.mask_set:
self.generate_mask_btn.setDisabled(True)
else:
self.generate_mask_btn.setDisabled(False)
def add_leave_biggest(self):
profile = self.calculation_plan.get_node().operation
profile.leave_biggest_swap()
self.calculation_plan.replace_step(profile)
self.plan.update_view()
def add_segmentation(self):
if self.segment_stack.currentIndex() == 0:
text = str(self.segment_profile.currentItem().text())
if text not in self.settings.segmentation_profiles:
self.refresh_all_profiles()
return
profile = self.settings.segmentation_profiles[text]
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(profile)
else:
self.calculation_plan.add_step(profile)
self.plan.update_view()
else: # self.segment_stack.currentIndex() == 1
text = self.pipeline_profile.currentItem().text()
segmentation_pipeline = self.settings.segmentation_pipelines[text]
pos = self.calculation_plan.current_pos[:]
old_pos = self.calculation_plan.current_pos[:]
for el in segmentation_pipeline.mask_history:
self.calculation_plan.add_step(el.segmentation)
self.plan.update_view()
node = self.calculation_plan.get_node(pos)
pos.append(len(node.children) - 1)
self.calculation_plan.set_position(pos)
self.calculation_plan.add_step(MaskCreate(
"", el.mask_property))
self.plan.update_view()
pos.append(0)
self.calculation_plan.set_position(pos)
self.calculation_plan.add_step(segmentation_pipeline.segmentation)
self.calculation_plan.set_position(old_pos)
self.plan.update_view()
def add_measurement(self):
text = str(self.measurements_list.currentItem().text())
measurement_copy = deepcopy(self.settings.measurement_profiles[text])
prefix = str(self.measurement_name_prefix.text()).strip()
channel = self.choose_channel_for_measurements.currentIndex() - 1
measurement_copy.name_prefix = prefix
# noinspection PyTypeChecker
measurement_calculate = MeasurementCalculate(
channel=channel,
statistic_profile=measurement_copy,
name_prefix=prefix,
units=self.units_choose.get_value())
if self.update_element_chk.isChecked():
self.calculation_plan.replace_step(measurement_calculate)
else:
self.calculation_plan.add_step(measurement_calculate)
self.plan.update_view()
def remove_element(self):
conflict_mask, used_mask = self.calculation_plan.get_file_mask_names()
if len(conflict_mask) > 0:
logging.info("Mask in use")
QMessageBox.warning(
self, "In use", "Masks {} are used in other places".format(
", ".join(conflict_mask)))
return
self.mask_set -= used_mask
self.calculation_plan.remove_step()
self.plan.update_view()
def clean_plan(self):
self.calculation_plan = CalculationPlan()
self.plan.set_plan(self.calculation_plan)
self.node_type_changed()
self.mask_set = set()
def mask_text_changed(self):
name = str(self.mask_name.text()).strip()
self.generate_mask_btn.setDisabled(True)
# load mask from file
if not self.update_element_chk.isChecked():
# generate mask from segmentation
if self.mask_allow and (name == "" or name not in self.mask_set):
self.generate_mask_btn.setEnabled(True)
else:
if self.node_type != NodeType.file_mask and self.node_type != NodeType.mask:
return
# generate mask from segmentation
if self.node_type == NodeType.mask and (
name == "" or name == self.node_name
or name not in self.mask_set):
self.generate_mask_btn.setEnabled(True)
def add_calculation_plan(self, text=None):
if text is None or isinstance(text, bool):
text, ok = QInputDialog.getText(self, "Plan title",
"Set plan title")
else:
text, ok = QInputDialog.getText(
self,
"Plan title",
"Set plan title. Previous ({}) is already in use".format(text),
text=text)
text = text.strip()
if ok:
if text == "":
QMessageBox.information(
self, "Name cannot be empty",
"Name cannot be empty, Please set correct name",
QMessageBox.Ok)
self.add_calculation_plan()
return
if text in self.settings.batch_plans:
res = QMessageBox.information(
self,
"Name already in use",
"Name already in use. Would like to overwrite?",
QMessageBox.Yes | QMessageBox.No,
)
if res == QMessageBox.No:
self.add_calculation_plan(text)
return
plan = copy(self.calculation_plan)
plan.set_name(text)
self.settings.batch_plans[text] = plan
self.settings.dump()
self.plan_created.emit()
@staticmethod
def get_index(item: QListWidgetItem, new_values: typing.List[str]) -> int:
if item is None:
return -1
text = item.text()
try:
return new_values.index(text)
except ValueError:
return -1
@staticmethod
def refresh_profiles(list_widget: QListWidget,
new_values: typing.List[str], index: int):
list_widget.clear()
list_widget.addItems(new_values)
if index != -1:
list_widget.setCurrentRow(index)
def showEvent(self, event):
self.refresh_all_profiles()
def refresh_all_profiles(self):
new_measurements = list(
sorted(self.settings.measurement_profiles.keys()))
new_segment = list(sorted(self.settings.segmentation_profiles.keys()))
new_pipelines = list(
sorted(self.settings.segmentation_pipelines.keys()))
measurement_index = self.get_index(
self.measurements_list.currentItem(), new_measurements)
segment_index = self.get_index(self.segment_profile.currentItem(),
new_segment)
pipeline_index = self.get_index(self.pipeline_profile.currentItem(),
new_pipelines)
self.protect = True
self.refresh_profiles(self.measurements_list, new_measurements,
measurement_index)
self.refresh_profiles(self.segment_profile, new_segment, segment_index)
self.refresh_profiles(self.pipeline_profile, new_pipelines,
pipeline_index)
self.protect = False
def show_measurement_info(self, text=None):
if self.protect:
return
if text is None:
if self.measurements_list.currentItem() is not None:
text = str(self.measurements_list.currentItem().text())
else:
return
profile = self.settings.measurement_profiles[text]
self.information.setText(str(profile))
def show_measurement(self):
if self.update_element_chk.isChecked():
if self.node_type == NodeType.measurement:
self.add_calculation_btn.setEnabled(True)
else:
self.add_calculation_btn.setDisabled(True)
else:
if self.measurements_list.currentItem() is not None:
self.add_calculation_btn.setEnabled(self.mask_allow)
else:
self.add_calculation_btn.setDisabled(True)
def show_segment_info(self, text=None):
if self.protect:
return
if text == "":
return
if self.segment_stack.currentIndex() == 0:
if text is None:
if self.segment_profile.currentItem() is not None:
text = str(self.segment_profile.currentItem().text())
else:
return
profile = self.settings.segmentation_profiles[text]
else:
if text is None:
if self.pipeline_profile.currentItem() is not None:
text = str(self.pipeline_profile.currentItem().text())
else:
return
profile = self.settings.segmentation_pipelines[text]
self.information.setText(profile.pretty_print(analysis_algorithm_dict))
def show_segment(self):
if self.update_element_chk.isChecked(
) and self.segment_stack.currentIndex() == 0:
self.get_big_btn.setDisabled(True)
if self.node_type == NodeType.segment:
self.chose_profile_btn.setEnabled(True)
else:
self.chose_profile_btn.setDisabled(True)
else:
if self.node_type == NodeType.segment:
self.get_big_btn.setEnabled(True)
else:
self.get_big_btn.setDisabled(True)
if self.segment_stack.currentIndex() == 0:
if self.segment_profile.currentItem() is not None:
self.chose_profile_btn.setEnabled(self.segment_allow)
else:
self.chose_profile_btn.setDisabled(True)
else:
if self.pipeline_profile.currentItem() is not None:
self.chose_profile_btn.setEnabled(self.segment_allow)
else:
self.chose_profile_btn.setDisabled(True)
def edit_plan(self):
plan = self.sender().plan_to_edit # type: CalculationPlan
self.calculation_plan = copy(plan)
self.plan.set_plan(self.calculation_plan)
self.mask_set.clear()
self.calculation_plan.set_position([])
self.mask_set.update(self.calculation_plan.get_mask_names())
