def rows_borders_added(self, links):
"""Add the links and the added row to the good rows
:param links: Old links to reput
"""
# Plus added to the last row
sources_images_dir = Config().getSourceImageDir()
add_search_bar_label = ClickableLabel()
add_search_bar_label.setObjectName('plus')
add_search_bar_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir,
"green_plus.png")))
add_search_bar_picture = add_search_bar_picture.scaledToHeight(20)
add_search_bar_label.setPixmap(add_search_bar_picture)
add_search_bar_label.clicked.connect(self.add_search_bar)
self.rows[len(self.rows) - 1][6] = add_search_bar_label
# Link added to every row, except the first one
for i in range(1, len(self.rows)):
row = self.rows[i]
link_choice = QComboBox()
link_choice.setObjectName('link')
link_choice.addItem("AND")
link_choice.addItem("OR")
if len(links) >= i:
link_choice.setCurrentText(links[i - 1])
row[0] = link_choice
def __init__(self, project, scan_list, main_window):
"""
Initialization of the IterationTable widget.
:param project: current project in the software
:param scan_list: list of the selected database files
:param main_window: software's main_window
"""
QWidget.__init__(self)
# Necessary for using MIA bricks
ProcessMIA.project = project
self.project = project
if not scan_list:
self.scan_list = self.project.session.get_documents_names(
COLLECTION_CURRENT)
else:
self.scan_list = scan_list
self.main_window = main_window
self.iterated_tag = None
# values_list will contain the different values of each selected tag
self.values_list = [[], []]
self.all_tag_values = []
# Checkbox to choose to iterate the pipeline or not
self.check_box_iterate = QCheckBox("Iterate pipeline")
self.check_box_iterate.stateChanged.connect(
self.emit_iteration_table_updated)
# Label "Iterate over:"
self.label_iterate = QLabel("Iterate over:")
# Label that displays the name of the selected tag
self.iterated_tag_label = QLabel("Select a tag")
# Push button to select the tag to iterate
self.iterated_tag_push_button = QPushButton("Select")
self.iterated_tag_push_button.clicked.connect(
self.select_iteration_tag)
# QComboBox
self.combo_box = QComboBox()
self.combo_box.currentIndexChanged.connect(self.update_table)
# filter
self.filter_button = QPushButton('Filter')
self.filter_button.clicked.connect(self.filter_values)
# QTableWidget
self.iteration_table = QTableWidget()
# Label tag
self.label_tags = QLabel("Tags to visualize:")
# Each push button will allow the user to visualize a tag in
# the iteration browser
push_button_tag_1 = QPushButton()
push_button_tag_1.setText("SequenceName")
push_button_tag_1.clicked.connect(
lambda: self.select_visualized_tag(0))
push_button_tag_2 = QPushButton()
push_button_tag_2.setText("AcquisitionDate")
push_button_tag_2.clicked.connect(
lambda: self.select_visualized_tag(1))
# The list of all the push buttons
# (the user can add as many as he or she wants)
self.push_buttons = []
self.push_buttons.insert(0, push_button_tag_1)
self.push_buttons.insert(1, push_button_tag_2)
# Labels to add/remove a tag (a push button)
self.add_tag_label = ClickableLabel()
self.add_tag_label.setObjectName('plus')
sources_images_dir = Config().getSourceImageDir()
add_tag_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir,
"green_plus.png")))
add_tag_picture = add_tag_picture.scaledToHeight(15)
self.add_tag_label.setPixmap(add_tag_picture)
self.add_tag_label.clicked.connect(self.add_tag)
self.remove_tag_label = ClickableLabel()
remove_tag_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir, "red_minus.png")))
remove_tag_picture = remove_tag_picture.scaledToHeight(20)
self.remove_tag_label.setPixmap(remove_tag_picture)
self.remove_tag_label.clicked.connect(self.remove_tag)
# Layout
self.v_layout = QVBoxLayout()
self.setLayout(self.v_layout)
self.refresh_layout()
class IterationTable(QWidget):
"""Widget that handles pipeline iteration.
.. Methods:
- add_tag: adds a tag to visualize in the iteration table
- emit_iteration_table_updated: emits a signal when the iteration
scans have been updated
- fill_values: fill values_list depending on the visualized tags
- refresh_layout: updates the layout of the widget
- remove_tag: removes a tag to visualize in the iteration table
- select_iterated_tag: opens a pop-up to let the user select on which
tag to iterate
- select_visualized_tag: opens a pop-up to let the user select which
tag to visualize in the iteration table
- update_iterated_tag: updates the widget
- update_table: updates the iteration table
"""
iteration_table_updated = pyqtSignal(list, list)
def __init__(self, project, scan_list, main_window):
"""
Initialization of the IterationTable widget.
:param project: current project in the software
:param scan_list: list of the selected database files
:param main_window: software's main_window
"""
QWidget.__init__(self)
# Necessary for using MIA bricks
ProcessMIA.project = project
self.project = project
if not scan_list:
self.scan_list = self.project.session.get_documents_names(
COLLECTION_CURRENT)
else:
self.scan_list = scan_list
self.main_window = main_window
self.iterated_tag = None
# values_list will contain the different values of each selected tag
self.values_list = [[], []]
self.all_tag_values = []
# Checkbox to choose to iterate the pipeline or not
self.check_box_iterate = QCheckBox("Iterate pipeline")
self.check_box_iterate.stateChanged.connect(
self.emit_iteration_table_updated)
# Label "Iterate over:"
self.label_iterate = QLabel("Iterate over:")
# Label that displays the name of the selected tag
self.iterated_tag_label = QLabel("Select a tag")
# Push button to select the tag to iterate
self.iterated_tag_push_button = QPushButton("Select")
self.iterated_tag_push_button.clicked.connect(
self.select_iteration_tag)
# QComboBox
self.combo_box = QComboBox()
self.combo_box.currentIndexChanged.connect(self.update_table)
# filter
self.filter_button = QPushButton('Filter')
self.filter_button.clicked.connect(self.filter_values)
# QTableWidget
self.iteration_table = QTableWidget()
# Label tag
self.label_tags = QLabel("Tags to visualize:")
# Each push button will allow the user to visualize a tag in
# the iteration browser
push_button_tag_1 = QPushButton()
push_button_tag_1.setText("SequenceName")
push_button_tag_1.clicked.connect(
lambda: self.select_visualized_tag(0))
push_button_tag_2 = QPushButton()
push_button_tag_2.setText("AcquisitionDate")
push_button_tag_2.clicked.connect(
lambda: self.select_visualized_tag(1))
# The list of all the push buttons
# (the user can add as many as he or she wants)
self.push_buttons = []
self.push_buttons.insert(0, push_button_tag_1)
self.push_buttons.insert(1, push_button_tag_2)
# Labels to add/remove a tag (a push button)
self.add_tag_label = ClickableLabel()
self.add_tag_label.setObjectName('plus')
sources_images_dir = Config().getSourceImageDir()
add_tag_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir,
"green_plus.png")))
add_tag_picture = add_tag_picture.scaledToHeight(15)
self.add_tag_label.setPixmap(add_tag_picture)
self.add_tag_label.clicked.connect(self.add_tag)
self.remove_tag_label = ClickableLabel()
remove_tag_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir, "red_minus.png")))
remove_tag_picture = remove_tag_picture.scaledToHeight(20)
self.remove_tag_label.setPixmap(remove_tag_picture)
self.remove_tag_label.clicked.connect(self.remove_tag)
# Layout
self.v_layout = QVBoxLayout()
self.setLayout(self.v_layout)
self.refresh_layout()
def add_tag(self):
"""Add a tag to visualize in the iteration table.
Used only for tests
"""
idx = len(self.push_buttons)
push_button = QPushButton()
push_button.setText('Tag n°' + str(len(self.push_buttons) + 1))
push_button.clicked.connect(lambda: self.select_visualized_tag(idx))
self.push_buttons.insert(len(self.push_buttons), push_button)
self.refresh_layout()
def emit_iteration_table_updated(self):
"""Emit a signal when the iteration scans have been updated."""
if self.check_box_iterate.checkState():
if hasattr(self, 'scans'):
self.iteration_table_updated.emit(self.iteration_scans,
self.all_iterations_scans)
else:
self.iteration_table_updated.emit(self.scan_list,
[self.scan_list])
else:
self.iteration_table_updated.emit(self.scan_list, [self.scan_list])
def fill_values(self, idx):
"""
Fill values_list depending on the visualized tags
:param idx: Index of the tag
"""
tag_name = self.push_buttons[idx].text()
values = []
for scan in self.project.session.get_documents_names(
COLLECTION_CURRENT):
current_value = self.project.session.get_value(
COLLECTION_CURRENT, scan, tag_name)
if current_value is not None:
values.append(current_value)
idx_to_fill = len(self.values_list)
while len(self.values_list) <= idx:
self.values_list.insert(idx_to_fill, [])
idx_to_fill += 1
if self.values_list[idx] is not None:
self.values_list[idx] = []
for value in values:
if value not in self.values_list[idx]:
self.values_list[idx].append(value)
def refresh_layout(self):
"""Update the layout of the widget.
Called in widget's initialization and when a tag push button
is added or removed.
"""
first_v_layout = QVBoxLayout()
first_v_layout.addWidget(self.check_box_iterate)
second_v_layout = QVBoxLayout()
second_v_layout.addWidget(self.label_iterate)
second_v_layout.addWidget(self.iterated_tag_label)
third_v_layout = QVBoxLayout()
third_v_layout.addWidget(self.iterated_tag_push_button)
hbox = QHBoxLayout()
hbox.addWidget(self.combo_box)
hbox.addWidget(self.filter_button)
third_v_layout.addLayout(hbox)
top_layout = QHBoxLayout()
top_layout.addLayout(first_v_layout)
top_layout.addLayout(second_v_layout)
top_layout.addLayout(third_v_layout)
self.v_layout.addLayout(top_layout)
self.v_layout.addWidget(self.iteration_table)
self.h_box = QHBoxLayout()
self.h_box.setSpacing(10)
self.h_box.addWidget(self.label_tags)
for tag_label in self.push_buttons:
self.h_box.addWidget(tag_label)
self.h_box.addWidget(self.add_tag_label)
self.h_box.addWidget(self.remove_tag_label)
self.h_box.addStretch(1)
self.v_layout.addLayout(self.h_box)
def remove_tag(self):
"""Remove a tag to visualize in the iteration table.
"""
if len(self.push_buttons) >= 1:
push_button = self.push_buttons[-1]
push_button.deleteLater()
push_button = None
del self.push_buttons[-1]
del self.values_list[-1]
self.refresh_layout()
def select_iteration_tag(self):
"""Open a pop-up to let the user select on which tag to iterate."""
ui_select = PopUpSelectTagCountTable(
self.project,
self.project.session.get_fields_names(COLLECTION_CURRENT),
self.iterated_tag)
if ui_select.exec_():
if self.iterated_tag is None and ui_select.selected_tag is None:
pass
else:
self.update_iterated_tag(ui_select.selected_tag)
def filter_values(self):
iterated_tag = self.iterated_tag
tag_values = self.all_tag_values
ui_iteration = PopUpSelectIteration(iterated_tag, tag_values)
if ui_iteration.exec_():
self.tag_values_list = [
t.replace('&', '') for t in ui_iteration.final_values
]
self.combo_box.clear()
self.combo_box.addItems(self.tag_values_list)
self.update_table()
def select_visualized_tag(self, idx):
"""Open a pop-up to let the user select which tag to visualize in the
iteration table.
:param idx: index of the clicked push button
"""
popUp = PopUpSelectTagCountTable(
self.project,
self.project.session.get_fields_names(COLLECTION_CURRENT),
self.push_buttons[idx].text())
if popUp.exec_() and popUp.selected_tag is not None:
self.push_buttons[idx].setText(popUp.selected_tag)
self.fill_values(idx)
self.update_table()
def update_iterated_tag(self, tag_name=None):
"""
Update the widget when the iterated tag is modified.
:param tag_name: name of the iterated tag
"""
if len(self.main_window.pipeline_manager.scan_list) > 0:
self.scan_list = self.main_window.pipeline_manager.scan_list
else:
self.scan_list = self.project.session.get_documents_names(
COLLECTION_CURRENT)
if tag_name is None:
tag_name = self.iterated_tag
self.iterated_tag_push_button.setText(tag_name)
self.iterated_tag = tag_name
self.iterated_tag_label.setText(tag_name + ":")
# Update combo_box
scans_names = self.project.session.get_documents_names(
COLLECTION_CURRENT)
scans_names = list(set(scans_names).intersection(self.scan_list))
# tag_values_list contains all the values that can take iterated tag
self.tag_values_list = []
for scan_name in scans_names:
tag_value = self.project.session.get_value(COLLECTION_CURRENT,
scan_name, tag_name)
if str(tag_value) not in self.tag_values_list:
self.tag_values_list.append(str(tag_value))
# duplucate the values list to have the initial, unfiltered, one
self.all_tag_values = list(self.tag_values_list)
self.combo_box.clear()
self.combo_box.addItems(self.tag_values_list)
self.update_table()
def update_table(self):
"""
Update the iteration table.
"""
# Updating the scan list
if not self.scan_list:
self.scan_list = self.project.session.get_documents_names(
COLLECTION_CURRENT)
# Clearing the table and preparing its columns
self.iteration_table.clear()
self.iteration_table.setColumnCount(len(self.push_buttons))
# Headers
for idx in range(len(self.push_buttons)):
# FIXME should not use GUI text values !!
header_name = self.push_buttons[idx].text().replace('&', '')
if header_name not in self.project.session.get_fields_names(
COLLECTION_CURRENT):
print("{0} not in the project's tags".format(header_name))
return
item = QTableWidgetItem()
item.setText(header_name)
self.iteration_table.setHorizontalHeaderItem(idx, item)
# Searching the database scans that correspond to iterated tag value
filter_query = "({" + str(self.iterated_tag) + "} " + "==" + " \"" + \
str(self.combo_box.currentText()).replace('&', '') + "\")"
scans_list = self.project.session.filter_documents(
COLLECTION_CURRENT, filter_query)
scans_res = [
getattr(document, TAG_FILENAME) for document in scans_list
]
# Taking the intersection between the found database scans and the
# user selection in the data_browser
self.iteration_scans = list(
set(scans_res).intersection(self.scan_list))
self.iteration_table.setRowCount(len(self.iteration_scans))
# Filling the table cells
row = -1
for scan_name in self.iteration_scans:
row += 1
for idx in range(len(self.push_buttons)):
tag_name = self.push_buttons[idx].text().replace('&', '')
item = QTableWidgetItem()
item.setText(
str(
self.project.session.get_value(COLLECTION_CURRENT,
scan_name, tag_name)))
self.iteration_table.setItem(row, idx, item)
all_iterations_scans = []
for tag_value in self.tag_values_list:
# Searching the database scans that correspond to iterated tag value
filter_query = "({" + str(self.iterated_tag) + "} " + "==" \
+ " \"" + str(tag_value) + "\")"
scans_list = self.project.session.filter_documents(
COLLECTION_CURRENT, filter_query)
scans_res = [
getattr(document, TAG_FILENAME) for document in scans_list
]
all_iterations_scans.append(
list(set(scans_res).intersection(self.scan_list)))
self.all_iterations_scans = all_iterations_scans
#self.scans = True
# This will change the scans list in the current Pipeline Manager tab
self.iteration_table_updated.emit(self.iteration_scans,
self.all_iterations_scans)
class CountTable(QDialog):
"""
Tool to precisely verify the scans of the project.
It is composed of push buttons on its top, each one corresponding to a tag
selected by the user.
When, the "Count scans" button is clicked, a table is created with all the
combinations possible for the values of the first n-1 tags. Then,
the m values that can take the last tag are displayed in the header of
the m last columns of the table. The cells are then filled with a green
plus or a red cross depending on if there is at least a scan that has
all the tags values or not.
.. Methods:
- add_tag: adds a tag to visualize in the count table
- count_scans: counts the number of scans depending on the selected
tags and displays the result in the table
- fill_first_tags: fills the cells of the table corresponding to the
(n-1) first selected tags
- fill_headers: fills the headers of the table depending on the
selected tags
- fill_last_tag: fills the cells corresponding to the last selected tag
- fill_values: fill values_list depending on the visualized tags
- prepare_filter: prepares the filter in order to fill the count table
- refresh_layout: updates the layout of the widget
- remove_tag: removes a tag to visualize in the count table
- select_tag: opens a pop-up to select which tag to visualize in
the count table
:Example:
Assume that the current project has scans for two patients (P1 and P2)
and three time points (T1, T2 and T3). For each (patient, time point),
several sequences have been made (two RARE, one MDEFT and one FLASH).
Selecting [PatientName, TimePoint, SequenceName] as tags, the table will
be:
+-------------+-----------+------+-------+-------+
| PatientName | TimePoint | RARE | MDEFT | FLASH |
+=============+===========+======+=======+=======+
| P1 | T1 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P1 | T2 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P1 | T3 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P2 | T1 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P2 | T2 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P2 | T3 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
with v(n) meaning that n scans corresponds of the selected values for
(PatientName, TimePoint,SequenceName).
If no scans corresponds for a triplet value, a red cross will be
displayed. For example, if the user forgets to import one RARE for P1 at
T2 and one FLASH for P2 at T3. The table will be:
+-------------+-----------+------+-------+-------+
| PatientName | TimePoint | RARE | MDEFT | FLASH |
+=============+===========+======+=======+=======+
| P1 | T1 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P1 | T2 | v(1) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P1 | T3 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P2 | T1 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P2 | T2 | v(2) | v(1) | v(1) |
+-------------+-----------+------+-------+-------+
| P2 | T3 | v(2) | v(1) | x |
+-------------+-----------+------+-------+-------+
Thus, thanks to the CountTable tool, he or she directly knows if some
scans are missing.
"""
def __init__(self, project):
"""
Initialization of the Count Table
:param project: current project in the software
"""
super().__init__()
self.project = project
# Issue #147: Allow to interact with database while the popup is open
# self.setModal(True)
self.setWindowTitle("Count table")
# Font
self.font = QFont()
self.font.setBold(True)
# values_list will contain the different values of each selected tag
self.values_list = [[], []]
self.label_tags = QLabel('Tags: ')
# Each push button will allow the user to add a tag to the count table
push_button_tag_1 = QPushButton()
push_button_tag_1.setText("Tag n°1")
push_button_tag_1.clicked.connect(lambda: self.select_tag(0))
push_button_tag_2 = QPushButton()
push_button_tag_2.setText("Tag n°2")
push_button_tag_2.clicked.connect(lambda: self.select_tag(1))
# The list of all the push buttons
# (the user can add as many as he or she wants)
self.push_buttons = []
self.push_buttons.insert(0, push_button_tag_1)
self.push_buttons.insert(1, push_button_tag_2)
# Labels to add/remove a tag (a push button)
sources_images_dir = Config().getSourceImageDir()
self.remove_tag_label = ClickableLabel()
remove_tag_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir, "red_minus.png")))
remove_tag_picture = remove_tag_picture.scaledToHeight(20)
self.remove_tag_label.setPixmap(remove_tag_picture)
self.remove_tag_label.clicked.connect(self.remove_tag)
self.add_tag_label = ClickableLabel()
self.add_tag_label.setObjectName('plus')
add_tag_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir,
"green_plus.png")))
add_tag_picture = add_tag_picture.scaledToHeight(15)
self.add_tag_label.setPixmap(add_tag_picture)
self.add_tag_label.clicked.connect(self.add_tag)
# Push button that is pressed to launch the computations
self.push_button_count = QPushButton()
self.push_button_count.setText('Count scans')
self.push_button_count.clicked.connect(self.count_scans)
# The table that will be filled
self.table = QTableWidget()
# Layouts
self.v_box_final = QVBoxLayout()
self.setLayout(self.v_box_final)
self.refresh_layout()
def add_tag(self):
"""
Adds a tag to visualize in the count table
"""
idx = len(self.push_buttons)
push_button = QPushButton()
push_button.setText('Tag n°' + str(len(self.push_buttons) + 1))
push_button.clicked.connect(lambda: self.select_tag(idx))
self.push_buttons.insert(len(self.push_buttons), push_button)
self.refresh_layout()
def count_scans(self):
"""Counts the number of scans depending on the selected tags and
displays the result in the table
"""
for tag_values in self.values_list:
if len(tag_values) == 0:
return
if self.project.session.get_field(
COLLECTION_CURRENT, self.push_buttons[-1].text()) is None:
return
# Clearing the table
self.table.clear()
# nb_values will contain, for each index, the number of
# different values that a tag can take
self.nb_values = []
for values in self.values_list:
self.nb_values.append(len(values))
# The number of rows will be the multiplication of all these
# values
self.nb_row = reduce(operator.mul, self.nb_values[:-1], 1)
# The number of columns will be the addition of the number of
# selected tags (minus 1) and the number of different values
# that can take the last selected tag
self.nb_col = len(self.values_list) - 1 + self.nb_values[-1]
self.table.setRowCount(self.nb_row)
self.table.setColumnCount(self.nb_col)
self.fill_headers()
self.fill_first_tags()
self.fill_last_tag()
self.table.resizeColumnsToContents()
def fill_first_tags(self):
"""Fills the cells of the table corresponding to the (n-1)
first selected tags
"""
cell_text = []
for col in range(len(self.values_list) - 1):
# cell_text will contain the n-1 element to display
cell_text.append(self.values_list[col][0])
# Filling the last "Total" column
item = QTableWidgetItem()
item.setText(str(self.nb_values[col]))
item.setFont(self.font)
self.table.setItem(self.nb_row, col, item)
# Filling the cells of the n-1 first tags
for row in range(self.nb_row):
for col in range(len(self.values_list) - 1):
item = QTableWidgetItem()
tag_name = self.push_buttons[col].text()
tag_type = self.project.session.get_field(
COLLECTION_CURRENT, tag_name).field_type
set_item_data(item, cell_text[col], tag_type)
self.table.setItem(row, col, item)
# Looping from the (n-1)th tag
col_checked = len(self.values_list) - 2
# Flag up will be True when all values of the tag
# have been iterated
flag_up = False
while col_checked >= 0:
if flag_up:
# In this case, the value of the right column has
# reach its last value
# This value has been reset to the first value
if (cell_text[col_checked] == self.values_list[col_checked]
[-1]):
# If the value that has been displayed is the
# last one, the flag stays the same, the value of
# the column on the left has to be changed
cell_text[col_checked] = self.values_list[col_checked][
0]
else:
# Else we iterate on the next value
idx = self.values_list[col_checked].index(
cell_text[col_checked])
cell_text[col_checked] = self.values_list[col_checked][
idx + 1]
flag_up = False
if (col_checked > 0 and len(self.values_list) - 1 > 1) or (
len(self.values_list) - 1 == 1):
if cell_text[col_checked] == self.values_list[col_checked][
-1]:
# If the value that has been displayed is the last one,
# the flag is set to True, the value of the column
# on the left has to be changed
cell_text[col_checked] = self.values_list[col_checked][
0]
flag_up = True
else:
# Else we iterate on the next value and reset the flag
idx = self.values_list[col_checked].index(
cell_text[col_checked])
cell_text[col_checked] = self.values_list[col_checked][
idx + 1]
flag_up = False
if not flag_up:
# If there is nothing to do, we quit the loop
break
col_checked -= 1
def fill_headers(self):
"""
Fills the headers of the table depending on the selected tags
"""
idx_end = 0
# Headers
for idx in range(len(self.values_list) - 1):
header_name = self.push_buttons[idx].text()
item = QTableWidgetItem()
item.setText(header_name)
self.table.setHorizontalHeaderItem(idx, item)
idx_end = idx
# idx_last_tag corresponds to the index of the (n-1)th tag
self.idx_last_tag = idx_end
last_tag = self.push_buttons[len(self.values_list) - 1].text()
last_tag_type = self.project.session.get_field(COLLECTION_CURRENT,
last_tag).field_type
for header_name in self.values_list[-1]:
idx_end += 1
item = QTableWidgetItem()
set_item_data(item, header_name, last_tag_type)
self.table.setHorizontalHeaderItem(idx_end, item)
# Adding a "Total" row and to count the scans
self.table.insertRow(self.nb_row)
item = QTableWidgetItem()
item.setText('Total')
item.setFont(self.font)
self.table.setVerticalHeaderItem(self.nb_row, item)
def fill_last_tag(self):
"""
Fills the cells corresponding to the last selected tag
"""
# Cells of the last tag
for col in range(self.idx_last_tag + 1, self.nb_col):
nb_scans_ok = 0
# Creating a tag_list that will contain
# couples tag_name/tag_value that
# will then querying the Database
for row in range(self.nb_row):
tag_list = []
for idx_first_columns in range(self.idx_last_tag + 1):
tag_name = self.table.horizontalHeaderItem(
idx_first_columns).text()
tag_type = self.project.session.get_field(
COLLECTION_CURRENT, tag_name).field_type
value_str = self.table.item(row, idx_first_columns).data(
Qt.EditRole)
value_database = table_to_database(value_str, tag_type)
tag_list.append([tag_name, value_database])
tag_last_columns = self.push_buttons[-1].text()
tag_last_columns_type = self.project.session.get_field(
COLLECTION_CURRENT, tag_last_columns).field_type
value_last_columns_str = self.table.horizontalHeaderItem(
col).data(Qt.EditRole)
value_last_columns_database = table_to_database(
value_last_columns_str, tag_last_columns_type)
tag_list.append(
[tag_last_columns, value_last_columns_database])
item = QTableWidgetItem()
item.setFlags(QtCore.Qt.ItemIsEnabled)
# Getting the list of the scans that corresponds to the couples
# tag_name/tag_values
generator_scans = self.project.session.filter_documents(
COLLECTION_CURRENT, self.prepare_filter(tag_list))
# List of scans created, given the generator
list_scans = [
getattr(scan, TAG_FILENAME) for scan in generator_scans
]
sources_images_dir = Config().getSourceImageDir()
if list_scans:
icon = QIcon(
os.path.join(sources_images_dir, 'green_v.png'))
length = len(list_scans)
nb_scans_ok += length
text = str(length)
item.setText(text)
tool_tip = ''
# Setting as tooltip all the corresponding scans
for tpl in list_scans:
tool_tip += (tpl + '\n')
tool_tip = tool_tip[:-1]
item.setToolTip(tool_tip)
else:
icon = QIcon(
os.path.join(sources_images_dir, 'red_cross.png'))
item.setIcon(icon)
self.table.setItem(row, col, item)
item = QTableWidgetItem()
item.setText(str(nb_scans_ok))
item.setFont(self.font)
self.table.setItem(self.nb_row, col, item)
def fill_values(self, idx):
"""
Fill values_list depending on the visualized tags
:param idx: index of the select tag
"""
tag_name = self.push_buttons[idx].text()
values = []
for scan in self.project.session.get_documents_names(
COLLECTION_CURRENT):
current_value = self.project.session.get_value(
COLLECTION_CURRENT, scan, tag_name)
if current_value is not None:
values.append(current_value)
idx_to_fill = len(self.values_list)
while len(self.values_list) <= idx:
self.values_list.insert(idx_to_fill, [])
idx_to_fill += 1
if self.values_list[idx] is not None:
self.values_list[idx] = []
for value in values:
if value not in self.values_list[idx]:
self.values_list[idx].append(value)
@staticmethod
def prepare_filter(couples):
"""
Prepares the filter in order to fill the count table
:param couples: (tag, value) couples
:return: Str query of the corresponding filter
"""
query = ""
and_to_write = False
for couple in couples:
tag = couple[0]
value = couple[1]
# No AND for the first condition
if and_to_write:
query += " AND "
and_to_write = True
if isinstance(value, list):
query += "({" + tag + "} == " + str(value) + ")"
else:
query += "({" + tag + "} == \"" + str(value) + "\")"
query = "(" + query + ")"
return query
def refresh_layout(self):
"""
Updates the layout of the widget
"""
self.h_box_top = QHBoxLayout()
self.h_box_top.setSpacing(10)
self.h_box_top.addWidget(self.label_tags)
for tag_label in self.push_buttons:
self.h_box_top.addWidget(tag_label)
self.h_box_top.addWidget(self.add_tag_label)
self.h_box_top.addWidget(self.remove_tag_label)
self.h_box_top.addWidget(self.push_button_count)
self.h_box_top.addStretch(1)
self.v_box_final.addLayout(self.h_box_top)
self.v_box_final.addWidget(self.table)
def remove_tag(self):
"""
Removes a tag to visualize in the count table
"""
push_button = self.push_buttons[-1]
push_button.deleteLater()
push_button = None
del self.push_buttons[-1]
del self.values_list[-1]
self.refresh_layout()
def select_tag(self, idx):
"""
Opens a pop-up to select which tag to visualize in the count table
:param idx: the index of the selected push button
"""
pop_up = PopUpSelectTagCountTable(
self.project,
self.project.session.get_fields_names(COLLECTION_CURRENT),
self.push_buttons[idx].text())
if pop_up.exec_():
if pop_up.selected_tag is not None:
self.push_buttons[idx].setText(pop_up.selected_tag)
self.fill_values(idx)
def __init__(self, project):
"""
Initialization of the Count Table
:param project: current project in the software
"""
super().__init__()
self.project = project
# Issue #147: Allow to interact with database while the popup is open
# self.setModal(True)
self.setWindowTitle("Count table")
# Font
self.font = QFont()
self.font.setBold(True)
# values_list will contain the different values of each selected tag
self.values_list = [[], []]
self.label_tags = QLabel('Tags: ')
# Each push button will allow the user to add a tag to the count table
push_button_tag_1 = QPushButton()
push_button_tag_1.setText("Tag n°1")
push_button_tag_1.clicked.connect(lambda: self.select_tag(0))
push_button_tag_2 = QPushButton()
push_button_tag_2.setText("Tag n°2")
push_button_tag_2.clicked.connect(lambda: self.select_tag(1))
# The list of all the push buttons
# (the user can add as many as he or she wants)
self.push_buttons = []
self.push_buttons.insert(0, push_button_tag_1)
self.push_buttons.insert(1, push_button_tag_2)
# Labels to add/remove a tag (a push button)
sources_images_dir = Config().getSourceImageDir()
self.remove_tag_label = ClickableLabel()
remove_tag_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir, "red_minus.png")))
remove_tag_picture = remove_tag_picture.scaledToHeight(20)
self.remove_tag_label.setPixmap(remove_tag_picture)
self.remove_tag_label.clicked.connect(self.remove_tag)
self.add_tag_label = ClickableLabel()
self.add_tag_label.setObjectName('plus')
add_tag_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir,
"green_plus.png")))
add_tag_picture = add_tag_picture.scaledToHeight(15)
self.add_tag_label.setPixmap(add_tag_picture)
self.add_tag_label.clicked.connect(self.add_tag)
# Push button that is pressed to launch the computations
self.push_button_count = QPushButton()
self.push_button_count.setText('Count scans')
self.push_button_count.clicked.connect(self.count_scans)
# The table that will be filled
self.table = QTableWidget()
# Layouts
self.v_box_final = QVBoxLayout()
self.setLayout(self.v_box_final)
self.refresh_layout()
def show_slices(self, file_paths):
"""Creates the thumbnails from the selected file paths.
:param file_paths: the selected file paths
"""
# If it's the first time that this function is called, the MiniViewer
# has to be shown
if self.first_time:
self.setHidden(False)
self.first_time = False
# If the user has willingly hidden the MiniViewer, the Processes are
# not made
if self.isHidden():
pass
else:
self.do_nothing = [False] * len(file_paths)
self.file_paths = file_paths
self.max_scans = len(file_paths)
self.setMinimumHeight(220)
self.clearLayouts()
self.frame = QFrame(self)
self.frame_final = QFrame(self)
# Limiting the legend of the thumbnails
self.nb_char_max = 60
font = QFont()
font.setPointSize(9)
# Reading the images from the file paths
for idx, file_path in enumerate(self.file_paths.copy()):
try:
self.img.insert(idx, nib.load(file_path))
except nib.filebasedimages.ImageFileError:
print("Error while trying to display the image " +
file_path)
self.file_paths.remove(file_path)
except FileNotFoundError:
print("File " + file_path + " not existing")
self.file_paths.remove(file_path)
# If we are in the "cursors" display mode
if self.check_box_slices.checkState() == Qt.Unchecked:
# Layout to aligne each thumbnail (image + cursors)
self.h_box_thumb = QHBoxLayout()
# idx represents the index of the selected image
for idx in range(min(self.max_scans, len(self.file_paths))):
if not self.do_nothing[idx]:
# Creating sliders and labels
self.boxSlider(idx)
self.enableSliders(idx)
self.createDimensionLabels(idx)
# Getting the sliders value and reading the image data
self.indexImage(idx)
# Making some pixel modification to display the image
# correctly
self.image2DModifications(idx)
self.displayPosValue(idx)
w, h = self.im_2D[idx].shape
im_Qt = QImage(self.im_2D[idx].data, w, h,
QImage.Format_Indexed8)
pixm = QPixmap.fromImage(im_Qt)
file_path_base_name = os.path.basename(
self.file_paths[idx])
# imageLabel is the label where the image is displayed
# (as a pixmap)
self.imageLabel.insert(idx, QLabel(self))
self.imageLabel[idx].setPixmap(pixm)
self.imageLabel[idx].setToolTip(file_path_base_name)
self.label_description.insert(idx, ClickableLabel())
self.label_description[idx].setFont(font)
self.label_description[idx].clicked.connect(
self.openTagsPopUp)
# Looking for the tag value to display as a
# legend of the thumbnail
file_path_base_name = os.path.relpath(
self.file_paths[idx], self.project.folder)
self.setThumbnail(file_path_base_name, idx)
# Layout that corresponds to the 3D dimension
self.h_box_slider_3D = QHBoxLayout()
self.h_box_slider_3D.addWidget(self.label3D[idx])
self.h_box_slider_3D.addWidget(self.txt_slider_3D[idx])
self.h_box_slider_3D.addWidget(self.slider_3D[idx])
# Layout that corresponds to the 4D dimension
self.h_box_slider_4D = QHBoxLayout()
self.h_box_slider_4D.addWidget(self.label4D[idx])
self.h_box_slider_4D.addWidget(self.txt_slider_4D[idx])
self.h_box_slider_4D.addWidget(self.slider_4D[idx])
# Layout that corresponds to the 5D dimension
self.h_box_slider_5D = QHBoxLayout()
self.h_box_slider_5D.addWidget(self.label5D[idx])
self.h_box_slider_5D.addWidget(self.txt_slider_5D[idx])
self.h_box_slider_5D.addWidget(self.slider_5D[idx])
# Layout for the three sliders
self.v_box_sliders = QVBoxLayout()
self.v_box_sliders.addLayout(self.h_box_slider_3D)
self.v_box_sliders.addLayout(self.h_box_slider_4D)
self.v_box_sliders.addLayout(self.h_box_slider_5D)
# Layout that corresponds to the image + the sliders
self.h_box = QHBoxLayout()
self.h_box.addWidget(self.imageLabel[idx])
self.h_box.addLayout(self.v_box_sliders)
# Layout that corresponds to the image and sliders +
# the description
self.v_box_thumb = QVBoxLayout()
self.v_box_thumb.addLayout(self.h_box)
self.v_box_thumb.addWidget(self.label_description[idx])
# Layout that will contain all the thumbnails
self.h_box_thumb.addLayout(self.v_box_thumb)
self.frame.setLayout(self.h_box_thumb)
# If we are in the "all slices" display mode
else:
self.h_box_images = QHBoxLayout()
self.h_box_images.setSpacing(10)
self.v_box_scans = QVBoxLayout()
# idx represents the index of the selected image
for idx in range(len(self.file_paths)):
file_path_base_name = os.path.relpath(
self.file_paths[idx], self.project.folder)
self.label_description.insert(idx, ClickableLabel())
self.label_description[idx].setFont(font)
self.label_description[idx].clicked.connect(
self.openTagsPopUp)
# Looking for the tag value to display as a legend
# of the thumbnail
self.setThumbnail(file_path_base_name, idx)
# Depending of the dimension of the image,
# the legend of each image and the number of images to
# display will change
if not self.do_nothing[idx]:
if len(self.img[idx].shape) == 3:
nb_slices = self.img[idx].shape[2]
txt = "Slice n°"
elif len(self.img[idx].shape) == 4:
nb_slices = self.img[idx].shape[3]
txt = "Time n°"
elif len(self.img[idx].shape) == 5:
nb_slices = self.img[idx].shape[4]
txt = "Study n°"
else:
nb_slices = 0
# Limiting the number of images to the number
# chosen by the user
for i in range(
min(nb_slices,
int(self.line_edit_nb_slices.text()))):
pixm = self.image_to_pixmap(self.img[idx], i)
self.v_box = QVBoxLayout()
# label corresponds to the label where one image
# is displayed
label = QLabel(self)
label.setPixmap(pixm)
label.setToolTip(
os.path.basename(self.file_paths[idx]))
# Legend of the image (depends on the number
# of dimensions)
label_info = QLabel()
label_info.setFont(font)
label_info.setText(txt + str(i + 1))
label_info.setAlignment(QtCore.Qt.AlignCenter)
self.v_box.addWidget(label)
self.v_box.addWidget(label_info)
# This layout allows to chain each image
self.h_box_images.addLayout(self.v_box)
self.v_box_scans.addLayout(self.h_box_images)
self.v_box_scans.addWidget(self.label_description[idx])
self.frame.setLayout(self.v_box_scans)
# Adding a scroll area if the thumbnails are too large
self.scroll_area = QScrollArea()
self.scroll_area.setWidget(self.frame)
self.h_box_check_box = QHBoxLayout()
if self.check_box_slices.isChecked():
self.h_box_check_box.addStretch(1)
self.label_nb_slices.setHidden(False)
self.line_edit_nb_slices.setHidden(False)
self.h_box_check_box.addWidget(self.label_nb_slices)
self.h_box_check_box.addWidget(self.line_edit_nb_slices)
self.check_box_cursors.setHidden(True)
else:
self.check_box_cursors.setHidden(False)
self.h_box_check_box.addWidget(self.check_box_cursors)
self.h_box_check_box.addStretch(1)
self.label_nb_slices.setHidden(True)
self.line_edit_nb_slices.setHidden(True)
self.h_box_check_box.addWidget(self.check_box_slices)
self.v_box_final.addLayout(self.h_box_check_box)
self.v_box_final.addWidget(self.scroll_area)
def add_search_bar(self):
"""Create and define the advanced research bar."""
row_layout = []
# NOT choice
not_choice = QComboBox()
not_choice.setObjectName('not')
not_choice.addItem("")
not_choice.addItem("NOT")
# Field choice
field_choice = QComboBox()
field_choice.setObjectName('field')
if len(self.tags_list) > 0:
for tag in self.tags_list:
field_choice.addItem(tag)
else:
for tag in self.project.session.get_shown_tags():
field_choice.addItem(tag)
field_choice.model().sort(0)
field_choice.addItem("All visualized tags")
# Value choice
condition_value = QLineEdit()
condition_value.setObjectName('value')
# Condition choice
condition_choice = QComboBox()
condition_choice.setObjectName('condition')
condition_choice.addItem("==")
condition_choice.addItem("!=")
condition_choice.addItem(">=")
condition_choice.addItem("<=")
condition_choice.addItem(">")
condition_choice.addItem("<")
condition_choice.addItem("BETWEEN")
condition_choice.addItem("IN")
condition_choice.addItem("CONTAINS")
condition_choice.addItem("HAS VALUE")
condition_choice.addItem("HAS NO VALUE")
condition_choice.model().sort(0)
# Signal to update the placeholder text of the value
condition_choice.currentTextChanged.connect(
lambda: self.displayValueRules(condition_choice, condition_value))
# Signal to update the list of conditions, depending on the tag type
field_choice.currentTextChanged.connect(
lambda: self.displayConditionRules(field_choice, condition_choice))
# Minus to remove the row
sources_images_dir = Config().getSourceImageDir()
remove_row_label = ClickableLabel()
remove_row_picture = QPixmap(
os.path.relpath(os.path.join(sources_images_dir, "red_minus.png")))
remove_row_picture = remove_row_picture.scaledToHeight(30)
remove_row_label.setPixmap(remove_row_picture)
# Everything appended to the row
row_layout.append(None) # Link room
row_layout.append(not_choice)
row_layout.append(field_choice)
row_layout.append(condition_choice)
row_layout.append(condition_value)
row_layout.append(remove_row_label)
row_layout.append(None) # Add row room
# Signal to remove the row
remove_row_label.clicked.connect(lambda: self.remove_row(row_layout))
self.rows.append(row_layout)
self.refresh_search()
self.displayConditionRules(field_choice, condition_choice)