def save_rtss(cls):
"""
Saves the RT Struct.
"""
patient_dict_container = PatientDictContainer()
rtss_directory = Path(patient_dict_container.get("file_rtss"))
patient_dict_container.get("dataset_rtss").save_as(rtss_directory)
def get_fused_window(level, window):
"""
Apply windowing on the fixed and moving (linear-registered) images.
Args:
level(int): the level (midpoint) of windowing
window(any): the window (range) of windowing
Return:
color_axial (QtGui.QPixmap): pixmap of the registered image from axial
view
color_sagittal (QtGui.QPixmap): pixmap of the registered image from
sagittal view
color_coronal (QtGui.QPixmap): pixmap of the registered image from
coronal view
tfm (sitk.CompositeTransform): transformation object containing data
that is a product from linear_registration
"""
patient_dict_container = PatientDictContainer()
old_images = patient_dict_container.get("sitk_original")
fused_image = patient_dict_container.get("fused_images")
tfm = fused_image[1]
array = sitk.GetArrayFromImage(old_images).shape
axial_slice_count = array[0]
coronal_slice_count = array[1]
sagittal_slice_count = array[1]
sp_plane, _, sp_slice = old_images.GetSpacing()
asp = (1.0 * sp_slice) / sp_plane
color_axial = {}
color_sagittal = {}
color_coronal = {}
windowing = (int(level - CT_RESCALE_INTERCEPT), int(window))
for i in range(axial_slice_count):
color_axial[i] = \
get_fused_pixmap(old_images, fused_image[0], asp, i, "axial",
windowing)
for i in range(sagittal_slice_count):
color_sagittal[i] = \
get_fused_pixmap(old_images, fused_image[0], asp, i, "sagittal",
windowing)
for i in range(coronal_slice_count):
color_coronal[i] = \
get_fused_pixmap(old_images, fused_image[0], asp, i, "coronal",
windowing)
return color_axial, color_sagittal, color_coronal, tfm
def read_images_for_fusion(level=0, window=0):
"""
Performs initial image fusion, this is by converting the old and
new images for transformations into SITK object. Images are co-registered
using SITK library. Images and SITK.CompositeTransformation objects are
added to the patient dataset.
Args:
level(int): midpoint of window
window(Any): range of values, should at least contain low bound and
high bound
"""
patient_dict_container = PatientDictContainer()
moving_dict_container = MovingDictContainer()
if level == 0 or window == 0:
level = patient_dict_container.get("level")
window = patient_dict_container.get("window")
amount = len(patient_dict_container.filepaths)
orig_fusion_list = []
for i in range(amount):
try:
orig_fusion_list.append(patient_dict_container.filepaths[i])
except KeyError:
continue
orig_image = sitk.ReadImage(orig_fusion_list)
patient_dict_container.set("sitk_original", orig_image)
amount = len(moving_dict_container.filepaths)
new_fusion_list = []
for i in range(amount):
try:
new_fusion_list.append(moving_dict_container.filepaths[i])
except KeyError:
continue
new_image = sitk.ReadImage(new_fusion_list)
moving_dict_container.set("sitk_moving", new_image)
create_fused_model(orig_image, new_image)
color_axial, color_sagittal, color_coronal, tfm = \
get_fused_window(level, window)
patient_dict_container.set("color_axial", color_axial)
patient_dict_container.set("color_sagittal", color_sagittal)
patient_dict_container.set("color_coronal", color_coronal)
moving_dict_container.set("tfm", tfm)
def test_create_roi():
rt_ss = dataset.Dataset()
rt_ss.StructureSetROISequence = []
rt_ss.StructureSetROISequence.append(dataset.Dataset())
rt_ss.StructureSetROISequence[0].ReferencedFrameOfReferenceUID = "1.2.3"
rt_ss.StructureSetROISequence[0].ROINumber = "1"
rt_ss.ROIContourSequence = []
rt_ss.RTROIObservationsSequence = []
roi_name = "NewTestROI"
roi_coordinates = [0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0,
0] # a closed right triangle
image_ds = dataset.Dataset()
image_ds.SOPClassUID = "1.2.840.10008.5.1.4.1.1.2"
image_ds.SOPInstanceUID = "1.2.3.4.5.6.7.8.9"
patient_dict_container = PatientDictContainer()
# container has to be initialised with kwargs content for the get/set to not fail for lack of an
# "additional_parameters" dict.
patient_dict_container.set_initial_values(None,
None,
None,
blah="blah",
rois={})
if patient_dict_container.get("rois") is not None:
print("rois are present in patient dict container")
updated_rtss = create_roi(rt_ss, roi_name, roi_coordinates, image_ds)
first_contour = updated_rtss.ROIContourSequence[0].ContourSequence[0]
assert (first_contour.ContourImageSequence[0].ReferencedSOPClassUID ==
image_ds.SOPClassUID)
assert (first_contour.ContourGeometricType == "CLOSED_PLANAR")
assert (rt_ss.RTROIObservationsSequence[0].RTROIInterpretedType == "ORGAN")
def on_loaded_suv2roi(self):
"""
Called when progress bar has finished. Closes the progress
window and refreshes the main screen.
"""
if self.suv2roi.suv2roi_status:
patient_dict_container = PatientDictContainer()
self.structures_tab.fixed_container_structure_modified((
patient_dict_container.get('dataset_rtss'), {"draw": None}))
else:
# Alert user that SUV2ROI failed and for what reason
if self.suv2roi.failure_reason == "UNIT":
failure_reason = \
"PET units are not Bq/mL. OnkoDICOM can currently only\n" \
"perform SUV2ROI on PET images stored in these units."
elif self.suv2roi.failure_reason == "DECY":
failure_reason = \
"PET is not decay corrected. OnkoDICOM can currently " \
"only\nperform SUV2ROI on PET images that are decay " \
"corrected."
else:
failure_reason = "The SUV2ROI process has failed."
button_reply = \
QtWidgets.QMessageBox(
QtWidgets.QMessageBox.Icon.Warning,
"SUV2ROI Failed",
failure_reason,
QtWidgets.QMessageBox.StandardButton.Ok, self)
button_reply.button(
QtWidgets.QMessageBox.StandardButton.Ok).setStyleSheet(
self.stylesheet)
button_reply.exec_()
# Close progress window
self.suv2roi_progress_window.close()
def update_ui(self):
# Instantiate a local new PatientDictContainer
patient_dict_container = PatientDictContainer()
patient = patient_dict_container.get("basic_info")
# Compare local patient with previous instance of ImageFusion
if self.patient_id != patient['id']:
self.update_patient()
def calculate_isodose_boundaries(self, isodose_levels):
"""
Calculates isodose boundaries for each isodose level.
:return: coutours, a list containing the countours for each
isodose level.
"""
# Initialise variables needed to find isodose levels
patient_dict_container = PatientDictContainer()
pixmaps = patient_dict_container.get("pixmaps_axial")
slider_min = 0
slider_max = len(pixmaps)
rt_plan_dose = patient_dict_container.dataset['rtdose']
rt_dose_dose = patient_dict_container.get("rx_dose_in_cgray")
# If rt_dose_dose does not exist, return None
if not rt_dose_dose:
return None
contours = {}
for item in isodose_levels:
# Calculate boundaries for each isodose level for each slice
contours[item] = []
for slider_id in range(slider_min, slider_max):
contours[item].append([])
temp_ds = patient_dict_container.dataset[slider_id]
z = temp_ds.ImagePositionPatient[2]
grid = get_dose_grid(rt_plan_dose, float(z))
if not (grid == []):
if isodose_levels[item][0]:
dose_level = isodose_levels[item][1] / \
(rt_plan_dose.DoseGridScaling * 100)
contours[item][slider_id] =\
(measure.find_contours(grid, dose_level))
else:
dose_level = isodose_levels[item][1] * \
rt_dose_dose / \
(rt_plan_dose.DoseGridScaling * 10000)
contours[item][slider_id] = \
(measure.find_contours(grid, dose_level))
# Return list of contours for each isodose level for each slice
return contours
def calculate_contours(self):
"""
Calculate SUV boundaries for each slice from an SUV value of 1
all the way to the maximum SUV value in that slice.
:return: Dictionary where key is SUV ROI name and value is
a list containing tuples of slice id and lists of
contours.
"""
# Create dictionary to store contour data
contour_data = {}
# Initialise variables needed for function
patient_dict_container = PatientDictContainer()
slider_min = 0
slider_max = len(patient_dict_container.get("pixmaps_axial"))
# Loop through each PET image in the dataset
for slider_id in range(slider_min, slider_max):
# Get SUV data from PET file
temp_ds = patient_dict_container.dataset[slider_id]
suv_data = self.pet2suv(temp_ds)
# Return None if PET 2 SUV failed
if suv_data is None:
return None
# Set current and max SUV for the current slice
current_suv = 1
max_suv = numpy.amax(suv_data)
# Continue calculating SUV contours for the slice until the
# max SUV has been reached.
while current_suv < max_suv:
# Find the contours for the SUV (i)
contours = measure.find_contours(suv_data, current_suv)
# Get the SUV name
name = "SUV-" + str(current_suv)
if name not in contour_data:
contour_data[name] = []
contour_data[name].append((slider_id, contours))
current_suv += 1
# Return contour data
return contour_data
class CalculateDVHProgressWindow(QtWidgets.QDialog):
signal_dvh_calculated = QtCore.pyqtSignal()
def __init__(self, *args, **kwargs):
super(CalculateDVHProgressWindow, self).__init__(*args, **kwargs)
layout = QtWidgets.QVBoxLayout()
text = QtWidgets.QLabel(
"Calculating DVHs... (This may take several minutes)")
layout.addWidget(text)
self.setWindowTitle("Please wait...")
self.setLayout(layout)
self.threadpool = QtCore.QThreadPool()
self.patient_dict_container = PatientDictContainer()
dataset_rtss = self.patient_dict_container.dataset["rtss"]
dataset_rtdose = self.patient_dict_container.dataset["rtdose"]
rois = self.patient_dict_container.get("rois")
dict_thickness = ImageLoading.get_thickness_dict(
dataset_rtss, self.patient_dict_container.dataset)
interrupt_flag = threading.Event()
fork_safe_platforms = ['Linux']
if platform.system() in fork_safe_platforms:
worker = Worker(ImageLoading.multi_calc_dvh, dataset_rtss,
dataset_rtdose, rois, dict_thickness)
else:
worker = Worker(ImageLoading.calc_dvhs, dataset_rtss,
dataset_rtdose, rois, dict_thickness,
interrupt_flag)
worker.signals.result.connect(self.dvh_calculated)
self.threadpool.start(worker)
def dvh_calculated(self, result):
dvh_x_y = ImageLoading.converge_to_0_dvh(result)
self.patient_dict_container.set("raw_dvh", result)
self.patient_dict_container.set("dvh_x_y", dvh_x_y)
self.signal_dvh_calculated.emit()
self.close()
def test_add_to_roi():
rt_ss = dataset.Dataset()
rt_ss.StructureSetROISequence = []
rt_ss.StructureSetROISequence.append(dataset.Dataset())
rt_ss.StructureSetROISequence[0].ReferencedFrameOfReferenceUID = "1.2.3"
rt_ss.StructureSetROISequence[0].ROINumber = "1"
rt_ss.StructureSetROISequence[0].ROIName = "NewTestROI"
rt_ss.ROIContourSequence = []
rt_ss.RTROIObservationsSequence = []
roi_name = "NewTestROI"
roi_coordinates = [0, 0, 0, 0, 1, 0, 1, 0, 0] # a right triangle
image_ds = dataset.Dataset()
image_ds.SOPClassUID = "1.2.840.10008.5.1.4.1.1.2"
image_ds.SOPInstanceUID = "1.2.3.4.5.6.7.8.9"
patient_dict_container = PatientDictContainer()
# container has to be initialised with kwargs content
# for the get/set to not fail for lack of an "additional_parameters" dict.
patient_dict_container.set_initial_values(None, None, None,
blah="blah", rois={})
if patient_dict_container.get("rois") is not None:
print("rois are present in patient dict container")
updated_rtss = create_roi(rt_ss, roi_name,
[{'coords': roi_coordinates, 'ds': image_ds}])
# clearly the above is an opportunity to factor out to a fixture or similar
rtss_with_added_roi = add_to_roi(updated_rtss, roi_name,
roi_coordinates, image_ds)
first_contour = rtss_with_added_roi.ROIContourSequence[0].\
ContourSequence[0]
second_contour = rtss_with_added_roi.ROIContourSequence[0].\
ContourSequence[1]
assert (
second_contour
.ContourImageSequence[0]
.ReferencedSOPClassUID
== image_ds.SOPClassUID
)
assert(first_contour.ContourGeometricType == "OPEN_PLANAR")
assert (second_contour.ContourGeometricType == "OPEN_PLANAR")
def closeEvent(self, event: QtGui.QCloseEvent) -> None:
patient_dict_container = PatientDictContainer()
if patient_dict_container.get("rtss_modified") \
and hasattr(self, "structures_tab"):
confirmation_dialog = QMessageBox.information(
self, 'Close without saving?',
'The RTSTRUCT file has been modified. Would you like to save '
'before exiting the program?',
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
if confirmation_dialog == QMessageBox.Save:
self.structures_tab.save_new_rtss_to_fixed_image_set()
event.accept()
self.cleanup()
elif confirmation_dialog == QMessageBox.Discard:
event.accept()
self.cleanup()
else:
event.ignore()
else:
self.cleanup()
def __init__(self, roi_id, color, text, structure_tab):
super(StructureWidget, self).__init__()
patient_dict_container = PatientDictContainer()
self.dataset_rtss = patient_dict_container.get("dataset_rtss")
self.roi_id = roi_id
self.color = color
self.text = text
self.structure_tab = structure_tab
self.standard_name = None
self.layout = QtWidgets.QHBoxLayout()
# Create color square
color_square_label = QtWidgets.QLabel()
color_square_pix = QtGui.QPixmap(15, 15)
color_square_pix.fill(self.color)
color_square_label.setPixmap(color_square_pix)
self.layout.addWidget(color_square_label)
# Create checkbox
checkbox = QtWidgets.QCheckBox()
checkbox.setFocusPolicy(QtCore.Qt.NoFocus)
checkbox.clicked.connect(lambda state, text_=roi_id: structure_tab.
structure_checked(state, text_))
if text in structure_tab.standard_organ_names or text in structure_tab.standard_volume_names:
self.standard_name = True
checkbox.setStyleSheet("font: 10pt \"Laksaman\";")
else:
self.standard_name = False
checkbox.setStyleSheet("font: 10pt \"Laksaman\"; color: red;")
for item in structure_tab.standard_volume_names: # Any suffix number will still be considered standard.
if text.startswith(item):
self.standard_name = True
checkbox.setStyleSheet("font: 10pt \"Laksaman\";")
checkbox.setText(text)
self.layout.addWidget(checkbox)
self.layout.setAlignment(Qt.AlignLeft)
self.setLayout(self.layout)
def update_rtss(self, patient):
"""
Updates the patient dict container with the newly created RTSS (if a
process generates one), so it can be used by future processes.
:param patient: The patient with the newly-created RTSS.
"""
# Get new RTSS
rtss = PatientDictContainer().dataset['rtss']
# Create a series and image from the RTSS
rtss_series = Series(rtss.SeriesInstanceUID)
rtss_series.series_description = rtss.get("SeriesDescription")
rtss_image = Image(PatientDictContainer().filepaths['rtss'],
rtss.SOPInstanceUID, rtss.SOPClassUID,
rtss.Modality)
rtss_series.add_image(rtss_image)
# Add the new study to the patient
patient.studies[rtss.StudyInstanceUID].add_series(rtss_series)
# Update the patient dict container
PatientDictContainer().set("rtss_modified", False)
def set_selected_roi_name(self, roi_name):
"""
function to set selected roi name
:param roi_name: roi name selected
"""
roi_exists = False
patient_dict_container = PatientDictContainer()
existing_rois = patient_dict_container.get("rois")
number_of_rois = len(existing_rois)
# Check to see if the ROI already exists
for key, value in existing_rois.items():
if roi_name in value['name']:
roi_exists = True
if roi_exists:
QMessageBox.about(self.draw_roi_window_instance,
"ROI already exists in RTSS",
"Would you like to continue?")
self.ROI_name = roi_name
self.roi_name_line_edit.setText(self.ROI_name)
class IsodoseTab(QtWidgets.QWidget):
request_update_isodoses = QtCore.pyqtSignal()
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.patient_dict_container = PatientDictContainer()
self.rx_dose_in_cgray = self.patient_dict_container.get("rx_dose_in_cgray")
self.color_dict = self.init_color_isod()
self.color_squares = self.init_color_squares()
self.checkboxes = self.init_checkboxes()
self.isodose_tab_layout = QtWidgets.QVBoxLayout()
self.isodose_tab_layout.setAlignment(QtCore.Qt.AlignTop)
self.isodose_tab_layout.setSpacing(0)
self.init_layout()
self.setLayout(self.isodose_tab_layout)
def init_layout(self):
for i in range(0, len(self.checkboxes)):
widget_isodose = QtWidgets.QWidget()
layout_isodose = QtWidgets.QHBoxLayout(widget_isodose)
layout_isodose.setAlignment(QtCore.Qt.AlignLeft)
layout_isodose.addWidget(self.color_squares[i])
layout_isodose.addWidget(self.checkboxes[i])
self.isodose_tab_layout.addWidget(widget_isodose)
def init_color_isod(self):
"""
Create a list containing the colors for each isodose.
:return: Dictionary where the key is the percentage of isodose and the value a QColor object.
"""
roi_color = {
107: QtGui.QColor(131, 0, 0),
105: QtGui.QColor(185, 0, 0),
100: QtGui.QColor(255, 46, 0),
95: QtGui.QColor(255, 161, 0),
90: QtGui.QColor(253, 255, 0),
80: QtGui.QColor(0, 255, 0),
70: QtGui.QColor(0, 143, 0),
60: QtGui.QColor(0, 255, 255),
30: QtGui.QColor(33, 0, 255),
10: QtGui.QColor(11, 0, 134)
}
return roi_color
def init_color_squares(self):
"""
Create a color square.
"""
list_of_squares = []
for key, color in self.color_dict.items():
list_of_squares.append(self.draw_color_square(color))
return list_of_squares
def init_checkboxes(self):
"""
Initialize the checkbox objects.
"""
list_of_checkboxes = []
# Values of Isodoses
list_of_doses = []
for percentage in isodose_percentages:
dose = int(self.rx_dose_in_cgray * (percentage / 100))
list_of_doses.append(dose)
# Checkboxes
first_iteration = True
for i in range(10):
if first_iteration:
checkbox = QtWidgets.QCheckBox("%s %% / %s cGy [Max]" % (str(isodose_percentages[i]),
str(list_of_doses[i])))
first_iteration = False
else:
checkbox = QtWidgets.QCheckBox("%s %% / %s cGy" % (str(isodose_percentages[i]), str(list_of_doses[i])))
checkbox.clicked.connect(lambda state, text=isodose_percentages[i]: self.checked_dose(state, text))
checkbox.setStyleSheet("font: 10pt \"Laksaman\";")
list_of_checkboxes.append(checkbox)
return list_of_checkboxes
# Function triggered when a dose level selected
# Updates the list of selected isodoses and dicom view
def checked_dose(self, state, isod_value):
"""
Function triggered when the checkbox of a structure is checked / unchecked.
Update the list of selected structures.
Update the DICOM view.
:param state: True if the checkbox is checked, False otherwise.
:param isod_value: Percentage of isodose.
"""
selected_doses = self.patient_dict_container.get("selected_doses")
if state:
# Add the dose to the list of selected doses
selected_doses.append(isod_value)
else:
# Remove dose from list of previously selected doses
selected_doses.remove(isod_value)
self.patient_dict_container.set("selected_doses", selected_doses)
# Update the dicom view
self.request_update_isodoses.emit()
def draw_color_square(self, color):
"""
Create a color square.
:param color: QColor object
:return: Color square widget.
"""
color_square_label = QtWidgets.QLabel()
color_square_pix = QtGui.QPixmap(15, 15)
color_square_pix.fill(color)
color_square_label.setPixmap(color_square_pix)
return color_square_label
class IsodoseTab(QtWidgets.QWidget):
request_update_isodoses = QtCore.Signal()
request_update_ui = QtCore.Signal(tuple)
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.patient_dict_container = PatientDictContainer()
self.rx_dose_in_cgray = self.patient_dict_container.get(
"rx_dose_in_cgray")
self.color_dict = self.init_color_isod()
self.color_squares = self.init_color_squares()
self.checkboxes = self.init_checkboxes()
# Create and initialise ISO2ROI button and layout
self.iso2roi_button = QtWidgets.QPushButton()
self.iso2roi_button.setText("Convert Isodoses to ROIs")
self.iso2roi_button.clicked.connect(self.iso2roi_button_clicked)
self.iso2roi_layout = QtWidgets.QHBoxLayout()
self.iso2roi_layout.setContentsMargins(0, 0, 0, 0)
self.iso2roi_layout.addWidget(self.iso2roi_button)
self.isodose_tab_layout = QtWidgets.QVBoxLayout()
self.isodose_tab_layout.setAlignment(QtCore.Qt.AlignTop
| QtCore.Qt.AlignTop)
self.isodose_tab_layout.setSpacing(0)
self.init_layout()
self.iso2roi = ISO2ROI()
# Add button to tab
self.isodose_tab_layout.addStretch()
self.isodose_tab_layout.addLayout(self.iso2roi_layout)
self.setLayout(self.isodose_tab_layout)
self.progress_window = ProgressWindow(
self, QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint)
self.progress_window.signal_loaded.connect(self.on_loaded_iso2roi)
def init_layout(self):
for i in range(0, len(self.checkboxes)):
widget_isodose = QtWidgets.QWidget()
layout_isodose = QtWidgets.QHBoxLayout(widget_isodose)
layout_isodose.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignLeft)
layout_isodose.addWidget(self.color_squares[i])
layout_isodose.addWidget(self.checkboxes[i])
self.isodose_tab_layout.addWidget(widget_isodose)
def init_color_isod(self):
"""
Create a list containing the colors for each isodose.
:return: Dictionary where the key is the percentage of isodose and the value a QColor object.
"""
roi_color = {
107: QtGui.QColor(131, 0, 0),
105: QtGui.QColor(185, 0, 0),
100: QtGui.QColor(255, 46, 0),
95: QtGui.QColor(255, 161, 0),
90: QtGui.QColor(253, 255, 0),
80: QtGui.QColor(0, 255, 0),
70: QtGui.QColor(0, 143, 0),
60: QtGui.QColor(0, 255, 255),
30: QtGui.QColor(33, 0, 255),
10: QtGui.QColor(11, 0, 134)
}
return roi_color
def init_color_squares(self):
"""
Create a color square.
"""
list_of_squares = []
for key, color in self.color_dict.items():
list_of_squares.append(self.draw_color_square(color))
return list_of_squares
def init_checkboxes(self):
"""
Initialize the checkbox objects.
"""
list_of_checkboxes = []
# Values of Isodoses
list_of_doses = []
for percentage in isodose_percentages:
dose = int(self.rx_dose_in_cgray * (percentage / 100))
list_of_doses.append(dose)
# Checkboxes
def generate_clicked_handler(text):
def handler(state):
self.checked_dose(state, text)
return handler
first_iteration = True
for i in range(10):
if first_iteration:
checkbox = QtWidgets.QCheckBox(
"%s %% / %s cGy [Max]" %
(str(isodose_percentages[i]), str(list_of_doses[i])))
first_iteration = False
else:
checkbox = QtWidgets.QCheckBox(
"%s %% / %s cGy" %
(str(isodose_percentages[i]), str(list_of_doses[i])))
checkbox.clicked.connect(
generate_clicked_handler(isodose_percentages[i]))
checkbox.setStyleSheet("font: 10pt \"Laksaman\";")
list_of_checkboxes.append(checkbox)
return list_of_checkboxes
# Function triggered when a dose level selected
# Updates the list of selected isodoses and dicom view
def checked_dose(self, state, isod_value):
"""
Function triggered when the checkbox of a structure is checked / unchecked.
Update the list of selected structures.
Update the DICOM view.
:param state: True if the checkbox is checked, False otherwise.
:param isod_value: Percentage of isodose.
"""
selected_doses = self.patient_dict_container.get("selected_doses")
if state:
# Add the dose to the list of selected doses
selected_doses.append(isod_value)
else:
# Remove dose from list of previously selected doses
selected_doses.remove(isod_value)
self.patient_dict_container.set("selected_doses", selected_doses)
# Update the dicom view
self.request_update_isodoses.emit()
def draw_color_square(self, color):
"""
Create a color square.
:param color: QColor object
:return: Color square widget.
"""
color_square_label = QtWidgets.QLabel()
color_square_pix = QtGui.QPixmap(15, 15)
color_square_pix.fill(color)
color_square_label.setPixmap(color_square_pix)
return color_square_label
def iso2roi_button_clicked(self):
"""
Clicked action handler for the ISO2ROI button.
Opens a progress window and Initiates the
ISO2ROI conversion process.
"""
self.progress_window.start(self.iso2roi.start_conversion)
def on_loaded_iso2roi(self):
"""
Called when progress bar has finished.
Closes the progress window and refreshes
the main screen.
"""
self.request_update_ui.emit(
(self.patient_dict_container.get('dataset_rtss'), {
"draw": None
}))
self.progress_window.close()
class StructureTab(QtWidgets.QWidget):
request_update_structures = QtCore.Signal()
def __init__(self, moving=False):
QtWidgets.QWidget.__init__(self)
self.patient_dict_container = PatientDictContainer()
self.moving_dict_container = MovingDictContainer()
self.rois = self.patient_dict_container.get("rois")
self.color_dict = self.init_color_roi(self.patient_dict_container)
self.patient_dict_container.set("roi_color_dict", self.color_dict)
self.structure_tab_layout = QtWidgets.QVBoxLayout()
self.roi_delete_handler = ROIDelOption(
self.fixed_container_structure_modified)
self.roi_draw_handler = ROIDrawOption(
self.fixed_container_structure_modified)
self.roi_manipulate_handler = ROIManipulateOption(
self.fixed_container_structure_modified)
# Create scrolling area widget to contain the content.
self.scroll_area = QtWidgets.QScrollArea()
self.scroll_area.setWidgetResizable(True)
self.scroll_area_content = QtWidgets.QWidget(self.scroll_area)
self.scroll_area.ensureWidgetVisible(self.scroll_area_content)
# Create layout for checkboxes and colour squares
self.layout_content = QtWidgets.QVBoxLayout(self.scroll_area_content)
self.layout_content.setContentsMargins(0, 0, 0, 0)
self.layout_content.setSpacing(0)
self.layout_content.setAlignment(QtCore.Qt.AlignTop
| QtCore.Qt.AlignTop)
# Create list of standard organ and volume names
self.standard_organ_names = []
self.standard_volume_names = []
self.init_standard_names()
# Create StructureWidget objects
self.update_content()
# Create a modified indicator
self.modified_indicator_widget = QtWidgets.QWidget()
self.modified_indicator_widget.setContentsMargins(8, 5, 8, 5)
modified_indicator_layout = QtWidgets.QHBoxLayout()
modified_indicator_layout.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignLeft)
modified_indicator_icon = QtWidgets.QLabel()
modified_indicator_icon.setPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/alert_icon.png")))
modified_indicator_layout.addWidget(modified_indicator_icon)
modified_indicator_text = QtWidgets.QLabel(
"Structures have been modified")
modified_indicator_text.setStyleSheet("color: red")
modified_indicator_layout.addWidget(modified_indicator_text)
self.modified_indicator_widget.setLayout(modified_indicator_layout)
self.modified_indicator_widget.mouseReleaseEvent = self.\
save_new_rtss_to_fixed_image_set
self.modified_indicator_widget.setVisible(False)
# Create ROI manipulation buttons
self.button_roi_manipulate = QtWidgets.QPushButton()
self.button_roi_draw = QtWidgets.QPushButton()
self.button_roi_delete = QtWidgets.QPushButton()
self.roi_buttons = QtWidgets.QWidget()
self.init_roi_buttons()
# Set layout
self.structure_tab_layout.addWidget(self.scroll_area)
self.structure_tab_layout.addWidget(self.modified_indicator_widget)
self.structure_tab_layout.addWidget(self.roi_buttons)
self.setLayout(self.structure_tab_layout)
def init_color_roi(self, dict_container):
"""
Create a dictionary containing the colors for each structure.
:param: either PatientDictContainer or MovingDictContainer
:return: Dictionary where the key is the ROI number and the value a
QColor object.
"""
roi_color = dict()
roi_contour_info = dict_container.get(
"dict_dicom_tree_rtss")['ROI Contour Sequence']
if len(roi_contour_info) > 0:
for item, roi_dict in roi_contour_info.items():
# Note: the keys of roiContourInfo are "item 0", "item 1",
# etc. As all the ROI structures are identified by the ROI
# numbers in the whole code, we get the ROI number 'roi_id'
# by using the member 'list_roi_numbers'
id = item.split()[1]
roi_id = dict_container.get("list_roi_numbers")[int(id)]
if 'ROI Display Color' in roi_contour_info[item]:
RGB_list = roi_contour_info[item]['ROI Display Color'][0]
red = RGB_list[0]
green = RGB_list[1]
blue = RGB_list[2]
else:
seed(1)
red = randint(0, 255)
green = randint(0, 255)
blue = randint(0, 255)
roi_color[roi_id] = QtGui.QColor(red, green, blue)
return roi_color
def init_standard_names(self):
"""
Create two lists containing standard organ and standard volume names
as set by the Add-On options.
"""
with open(data_path('organName.csv'), 'r') as f:
self.standard_organ_names = []
csv_input = csv.reader(f)
header = next(f) # Ignore the "header" of the column
for row in csv_input:
self.standard_organ_names.append(row[0])
with open(data_path('volumeName.csv'), 'r') as f:
self.standard_volume_names = []
csv_input = csv.reader(f)
header = next(f) # Ignore the "header" of the column
for row in csv_input:
self.standard_volume_names.append(row[1])
def init_roi_buttons(self):
icon_roi_delete = QtGui.QIcon()
icon_roi_delete.addPixmap(
QtGui.QPixmap(
resource_path('res/images/btn-icons/delete_icon.png')),
QtGui.QIcon.Normal, QtGui.QIcon.On)
icon_roi_draw = QtGui.QIcon()
icon_roi_draw.addPixmap(
QtGui.QPixmap(resource_path('res/images/btn-icons/draw_icon.png')),
QtGui.QIcon.Normal, QtGui.QIcon.On)
icon_roi_manipulate = QtGui.QIcon()
icon_roi_manipulate.addPixmap(
QtGui.QPixmap(
resource_path('res/images/btn-icons/manipulate_icon.png')),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.button_roi_delete.setIcon(icon_roi_delete)
self.button_roi_delete.setText("Delete ROI")
self.button_roi_delete.clicked.connect(self.roi_delete_clicked)
self.button_roi_draw.setIcon(icon_roi_draw)
self.button_roi_draw.setText("Draw ROI")
self.button_roi_draw.clicked.connect(self.roi_draw_clicked)
self.button_roi_manipulate.setIcon(icon_roi_manipulate)
self.button_roi_manipulate.setText("Manipulate ROI")
self.button_roi_manipulate.clicked.connect(self.roi_manipulate_clicked)
layout_roi_buttons = QtWidgets.QVBoxLayout(self.roi_buttons)
layout_roi_buttons.setContentsMargins(0, 0, 0, 0)
layout_roi_buttons.addWidget(self.button_roi_draw)
layout_roi_buttons.addWidget(self.button_roi_manipulate)
layout_roi_buttons.addWidget(self.button_roi_delete)
def update_ui(self, moving=False):
"""
Update the UI of Structure Tab when a new patient is opened
"""
self.patient_dict_container = PatientDictContainer()
self.rois = self.patient_dict_container.get("rois")
self.color_dict = self.init_color_roi(self.patient_dict_container)
self.patient_dict_container.set("roi_color_dict", self.color_dict)
if hasattr(self, "modified_indicator_widget"):
self.modified_indicator_widget.setParent(None)
self.update_content()
def update_content(self):
"""
Add the contents (color square and checkbox) in the scrolling area
widget.
"""
# Clear the children
for i in reversed(range(self.layout_content.count())):
self.layout_content.itemAt(i).widget().setParent(None)
row = 0
for roi_id, roi_dict in self.rois.items():
# Creates a widget representing each ROI
color = self.color_dict[roi_id]
color.setAlpha(255)
structure = StructureWidget(roi_id, color, roi_dict['name'], self)
if roi_id in self.patient_dict_container.get("selected_rois"):
structure.checkbox.setChecked(Qt.Checked)
structure.structure_renamed.\
connect(self.fixed_container_structure_modified)
self.layout_content.addWidget(structure)
row += 1
self.scroll_area.setStyleSheet(
"QScrollArea {background-color: #ffffff; border-style: none;}")
self.scroll_area_content.setStyleSheet(
"QWidget {background-color: #ffffff; border-style: none;}")
self.scroll_area.setWidget(self.scroll_area_content)
def roi_delete_clicked(self):
self.roi_delete_handler.show_roi_delete_options()
def roi_draw_clicked(self):
self.roi_draw_handler.show_roi_draw_options()
def roi_manipulate_clicked(self):
""" Open ROI Manipulate Window """
self.roi_manipulate_handler.show_roi_manipulate_options(
self.color_dict)
def moving_container_structure_modified(self, changes):
"""
Executes when a structure of moving container is modified.
Changes is a tuple of (new_dataset,
description_of_changes)
description_of_changes follows the format
{"type_of_change": value_of_change}.
Examples:
{"rename": ["TOOTH", "TEETH"]} represents that the TOOTH structure has
been renamed to TEETH.
{"delete": ["TEETH", "MAXILLA"]} represents that the TEETH and MAXILLA
structures have been deleted.
{"draw": "AORTA"} represents that a new structure AORTA has been drawn.
Note: Use {"draw": None} after multiple ROIs are generated
(E.g., from ISO2ROI functionality), and use {"transfer":None} for
ROI Transfer instead of calling this function
multiple times. This will trigger auto save.
"""
new_dataset = changes[0]
change_description = changes[1]
# If this is the first change made to the RTSS file, update the
# dataset with the new one so that OnkoDICOM starts working off this
# dataset rather than the original RTSS file.
self.moving_dict_container.set("rtss_modified", True)
self.moving_dict_container.set("dataset_rtss", new_dataset)
# Refresh ROIs in main page
self.moving_dict_container.set("rois",
ImageLoading.get_roi_info(new_dataset))
self.rois = self.moving_dict_container.get("rois")
contour_data = ImageLoading.get_raw_contour_data(new_dataset)
self.moving_dict_container.set("raw_contour", contour_data[0])
self.moving_dict_container.set("num_points", contour_data[1])
pixluts = ImageLoading.get_pixluts(self.moving_dict_container.dataset)
self.moving_dict_container.set("pixluts", pixluts)
self.moving_dict_container.set(
"list_roi_numbers",
ordered_list_rois(self.moving_dict_container.get("rois")))
self.moving_dict_container.set("selected_rois", [])
self.moving_dict_container.set("dict_polygons_axial", {})
self.moving_dict_container.set("dict_polygons_sagittal", {})
self.moving_dict_container.set("dict_polygons_coronal", {})
if "draw" in change_description or "transfer" in change_description:
dicom_tree_rtss = DicomTree(None)
dicom_tree_rtss.dataset = new_dataset
dicom_tree_rtss.dict = dicom_tree_rtss.dataset_to_dict(
dicom_tree_rtss.dataset)
self.moving_dict_container.set("dict_dicom_tree_rtss",
dicom_tree_rtss.dict)
self.color_dict = self.init_color_roi(self.moving_dict_container)
self.moving_dict_container.set("roi_color_dict", self.color_dict)
if self.moving_dict_container.has_attribute("raw_dvh"):
# DVH will be outdated once changes to it are made, and
# recalculation will be required.
self.moving_dict_container.set("dvh_outdated", True)
if self.moving_dict_container.has_modality("raw_dvh"):
# Rename structures in DVH list
if "rename" in change_description:
new_raw_dvh = self.moving_dict_container.get("raw_dvh")
for key, dvh in new_raw_dvh.items():
if dvh.name == change_description["rename"][0]:
dvh.name = change_description["rename"][1]
break
self.moving_dict_container.set("raw_dvh", new_raw_dvh)
# Remove structures from DVH list - the only visible effect of
# this section is the exported DVH csv
if "delete" in change_description:
list_of_deleted = []
new_raw_dvh = self.moving_dict_container.get("raw_dvh")
for key, dvh in new_raw_dvh.items():
if dvh.name in change_description["delete"]:
list_of_deleted.append(key)
for key in list_of_deleted:
new_raw_dvh.pop(key)
self.moving_dict_container.set("raw_dvh", new_raw_dvh)
if "transfer" in change_description \
and change_description["transfer"] is None:
self.save_new_rtss_to_moving_image_set()
def fixed_container_structure_modified(self, changes):
"""
Executes when a structure of fixed patient container is modified
Displays indicator that structure has changed.
Changes is a tuple of (new_dataset,
description_of_changes)
description_of_changes follows the format
{"type_of_change": value_of_change}.
Examples:
{"rename": ["TOOTH", "TEETH"]} represents that the TOOTH structure has
been renamed to TEETH.
{"delete": ["TEETH", "MAXILLA"]} represents that the TEETH and MAXILLA
structures have been deleted.
{"draw": "AORTA"} represents that a new structure AORTA has been drawn.
Note: Use {"draw": None} after multiple ROIs are generated
(E.g., from ISO2ROI functionality), and use {"transfer":None} for
ROI Transfer instead of calling this function
multiple times. This will trigger auto save.
"""
new_dataset = changes[0]
change_description = changes[1]
# Only show the modified indicator if description_of_changes is
# not {"draw": None}, as this description means that the RTSS
# is autosaved, and therefore there is no need to tell the user
# that the RTSS has been modified
if not("draw" in change_description
and change_description["draw"] is None) and \
not ("transfer" in change_description):
self.show_modified_indicator()
# If this is the first change made to the RTSS file, update the
# dataset with the new one so that OnkoDICOM starts working off this
# dataset rather than the original RTSS file.
self.patient_dict_container.set("rtss_modified", True)
self.patient_dict_container.set("dataset_rtss", new_dataset)
# Refresh ROIs in main page
self.patient_dict_container.set("rois",
ImageLoading.get_roi_info(new_dataset))
self.rois = self.patient_dict_container.get("rois")
contour_data = ImageLoading.get_raw_contour_data(new_dataset)
self.patient_dict_container.set("raw_contour", contour_data[0])
self.patient_dict_container.set("num_points", contour_data[1])
pixluts = ImageLoading.get_pixluts(self.patient_dict_container.dataset)
self.patient_dict_container.set("pixluts", pixluts)
self.patient_dict_container.set(
"list_roi_numbers",
ordered_list_rois(self.patient_dict_container.get("rois")))
self.patient_dict_container.set("selected_rois", [])
self.patient_dict_container.set("dict_polygons_axial", {})
self.patient_dict_container.set("dict_polygons_sagittal", {})
self.patient_dict_container.set("dict_polygons_coronal", {})
if "draw" in change_description or "transfer" in change_description:
dicom_tree_rtss = DicomTree(None)
dicom_tree_rtss.dataset = new_dataset
dicom_tree_rtss.dict = dicom_tree_rtss.dataset_to_dict(
dicom_tree_rtss.dataset)
self.patient_dict_container.set("dict_dicom_tree_rtss",
dicom_tree_rtss.dict)
self.color_dict = self.init_color_roi(self.patient_dict_container)
self.patient_dict_container.set("roi_color_dict", self.color_dict)
if self.patient_dict_container.has_attribute("raw_dvh"):
# DVH will be outdated once changes to it are made, and
# recalculation will be required.
self.patient_dict_container.set("dvh_outdated", True)
if self.patient_dict_container.has_attribute("raw_dvh"):
# Rename structures in DVH list
if "rename" in change_description:
new_raw_dvh = self.patient_dict_container.get("raw_dvh")
for key, dvh in new_raw_dvh.items():
if dvh.name == change_description["rename"][0]:
dvh.name = change_description["rename"][1]
break
self.patient_dict_container.set("raw_dvh", new_raw_dvh)
dvh2rtdose(new_raw_dvh)
# Remove structures from DVH list - the only visible effect of
# this section is the exported DVH csv
if "delete" in change_description:
list_of_deleted = []
new_raw_dvh = self.patient_dict_container.get("raw_dvh")
for key, dvh in new_raw_dvh.items():
if dvh.name in change_description["delete"]:
list_of_deleted.append(key)
for key in list_of_deleted:
new_raw_dvh.pop(key)
self.patient_dict_container.set("raw_dvh", new_raw_dvh)
dvh2rtdose(new_raw_dvh)
# Refresh ROIs in DVH tab and DICOM View
self.request_update_structures.emit()
# Refresh structure tab
self.update_content()
if "draw" in change_description and change_description["draw"] is None:
self.save_new_rtss_to_fixed_image_set(auto=True)
elif "transfer" in change_description \
and change_description["transfer"] is None:
self.save_new_rtss_to_fixed_image_set(auto=True)
def show_modified_indicator(self):
self.modified_indicator_widget.setVisible(True)
def structure_checked(self, state, roi_id):
"""
Function triggered when the checkbox of a structure is
checked / unchecked.
Update the list of selected structures.
Update the plot of the DVH and the DICOM view.
:param state: True if the checkbox is checked, False otherwise.
:param roi_id: ROI number
"""
selected_rois = self.patient_dict_container.get("selected_rois")
if state:
selected_rois.append(roi_id)
else:
selected_rois.remove(roi_id)
self.patient_dict_container.set("selected_rois", selected_rois)
self.update_dict_polygons(state, roi_id)
self.request_update_structures.emit()
def update_dict_polygons(self, state, roi_id):
"""
Update the polygon dictionaries (axial, coronal, sagittal) used to
display the ROIs.
:param state: True if the ROI is selected, False otherwise
:param roi_id: ROI number
"""
rois = self.patient_dict_container.get("rois")
new_dict_polygons_axial = self.patient_dict_container.get(
"dict_polygons_axial")
new_dict_polygons_coronal = self.patient_dict_container.get(
"dict_polygons_coronal")
new_dict_polygons_sagittal = self.patient_dict_container.get(
"dict_polygons_sagittal")
aspect = self.patient_dict_container.get("pixmap_aspect")
roi_name = rois[roi_id]['name']
if state:
new_dict_polygons_axial[roi_name] = {}
new_dict_polygons_coronal[roi_name] = {}
new_dict_polygons_sagittal[roi_name] = {}
dict_rois_contours_axial = get_roi_contour_pixel(
self.patient_dict_container.get("raw_contour"), [roi_name],
self.patient_dict_container.get("pixluts"))
dict_rois_contours_coronal, dict_rois_contours_sagittal = \
transform_rois_contours(
dict_rois_contours_axial)
for slice_id in self.patient_dict_container.get(
"dict_uid").values():
polygons = calc_roi_polygon(roi_name, slice_id,
dict_rois_contours_axial)
new_dict_polygons_axial[roi_name][slice_id] = polygons
for slice_id in range(
0,
len(self.patient_dict_container.get("pixmaps_coronal"))):
polygons_coronal = calc_roi_polygon(
roi_name, slice_id, dict_rois_contours_coronal,
aspect["coronal"])
polygons_sagittal = calc_roi_polygon(
roi_name, slice_id, dict_rois_contours_sagittal,
1 / aspect["sagittal"])
new_dict_polygons_coronal[roi_name][
slice_id] = polygons_coronal
new_dict_polygons_sagittal[roi_name][
slice_id] = polygons_sagittal
self.patient_dict_container.set("dict_polygons_axial",
new_dict_polygons_axial)
self.patient_dict_container.set("dict_polygons_coronal",
new_dict_polygons_coronal)
self.patient_dict_container.set("dict_polygons_sagittal",
new_dict_polygons_sagittal)
else:
new_dict_polygons_axial.pop(roi_name, None)
new_dict_polygons_coronal.pop(roi_name, None)
new_dict_polygons_sagittal.pop(roi_name, None)
def on_rtss_selected(self, selected_rtss):
"""
Function to run after a rtss is selected from SelectRTSSPopUp
"""
self.patient_dict_container.get("existing_rtss_files").clear()
self.patient_dict_container.get("existing_rtss_files").append(
selected_rtss)
self.save_new_rtss(auto=True)
def display_select_rtss_window(self):
"""
Display a pop up window that contains all RTSSs attached to the
selected image set.
"""
self.select_rtss_window = SelectRTSSPopUp(
self.patient_dict_container.get("existing_rtss_files"),
parent=self)
self.select_rtss_window.signal_rtss_selected.connect(
self.on_rtss_selected)
self.select_rtss_window.show()
def save_new_rtss_to_fixed_image_set(self, event=None, auto=False):
"""
Save the current RTSS stored in fixed patient dictionary to the file
system. :param event: Not used but will be passed as an argument
from modified_indicator_widget on mouseReleaseEvent :param auto:
Used for auto save without user confirmation
"""
existing_rtss_files = self.patient_dict_container.get(
"existing_rtss_files")
if len(existing_rtss_files) == 1:
if isinstance(existing_rtss_files[0], Series):
existing_rtss_directory = str(
Path(existing_rtss_files[0].get_files()[0]))
else:
# This "else" is used by iso2roi gui and structure tab tests to
# quickly set existing_rtss_directory
existing_rtss_directory = existing_rtss_files[0]
elif len(existing_rtss_files) > 1:
self.display_select_rtss_window()
# This function will be called again when a RTSS is selected
return
else:
existing_rtss_directory = None
rtss_directory = str(Path(
self.patient_dict_container.get("file_rtss")))
if auto:
confirm_save = QtWidgets.QMessageBox.Yes
else:
confirm_save = \
QtWidgets.QMessageBox.information(self, "Confirmation",
"Are you sure you want to "
"save the modified RTSTRUCT "
"file? This will overwrite "
"the existing file. This is "
"not reversible.",
QtWidgets.QMessageBox.Yes,
QtWidgets.QMessageBox.No)
if confirm_save == QtWidgets.QMessageBox.Yes:
if existing_rtss_directory is None:
self.patient_dict_container.get("dataset_rtss").save_as(
rtss_directory)
else:
new_rtss = self.patient_dict_container.get("dataset_rtss")
old_rtss = pydicom.dcmread(existing_rtss_directory, force=True)
old_roi_names = \
set(value["name"] for value in
ImageLoading.get_roi_info(old_rtss).values())
new_roi_names = \
set(value["name"] for value in
self.patient_dict_container.get("rois").values())
duplicated_names = old_roi_names.intersection(new_roi_names)
# stop if there are conflicting roi names and user do not
# wish to proceed.
if duplicated_names and not self.display_confirm_merge(
duplicated_names):
return
merged_rtss = merge_rtss(old_rtss, new_rtss, duplicated_names)
merged_rtss.save_as(existing_rtss_directory)
if not auto:
QtWidgets.QMessageBox.about(
self.parentWidget(), "File saved",
"The RTSTRUCT file has been saved.")
self.patient_dict_container.set("rtss_modified", False)
# Hide the modified indicator
self.modified_indicator_widget.setVisible(False)
def save_new_rtss_to_moving_image_set(self, event=None):
"""
Save the current RTSS stored in moving patient dictionary to the
file system. ROIs modification into moving patient dict is auto
saved :param event: Not used but will be passed as an argument from
modified_indicator_widget on mouseReleaseEvent
"""
if self.moving_dict_container.get("existing_file_rtss") is not None:
existing_rtss_directory = str(
Path(self.moving_dict_container.get("existing_file_rtss")))
else:
existing_rtss_directory = None
rtss_directory = str(Path(self.moving_dict_container.get("file_rtss")))
if existing_rtss_directory is None:
self.moving_dict_container.get("dataset_rtss").save_as(
rtss_directory)
else:
new_rtss = self.moving_dict_container.get("dataset_rtss")
old_rtss = pydicom.dcmread(existing_rtss_directory, force=True)
old_roi_names = \
set(value["name"] for value in
ImageLoading.get_roi_info(old_rtss).values())
new_roi_names = \
set(value["name"] for value in
self.moving_dict_container.get("rois").values())
duplicated_names = old_roi_names.intersection(new_roi_names)
merged_rtss = merge_rtss(old_rtss, new_rtss, duplicated_names)
merged_rtss.save_as(existing_rtss_directory)
self.moving_dict_container.set("rtss_modified", False)
def display_confirm_merge(self, duplicated_names):
confirm_merge = QtWidgets.QMessageBox(parent=self)
confirm_merge.setIcon(QtWidgets.QMessageBox.Question)
confirm_merge.setWindowTitle("Merge RTSTRUCTs?")
confirm_merge.setText("Conflicting ROI names found between new ROIs "
"and existing ROIs:\n" + str(duplicated_names) +
"\nAre you sure you want to merge the RTSTRUCT "
"files? The new ROIs will replace the existing "
"ROIs. ")
button_yes = QtWidgets.QPushButton("Yes, I want to merge")
button_no = QtWidgets.QPushButton("No, I will change the names")
"""
We want the buttons 'No' & 'Yes' to be displayed in that exact
order. QMessageBox displays buttons in respect to their assigned
roles. (0 first, then 0 and so on) 'AcceptRole' is 0 and
'RejectRole' is 1 thus by counterintuitively assigning 'No' to
'AcceptRole' and 'Yes' to 'RejectRole' the buttons are
positioned as desired.
"""
confirm_merge.addButton(button_no, QtWidgets.QMessageBox.AcceptRole)
confirm_merge.addButton(button_yes, QtWidgets.QMessageBox.RejectRole)
confirm_merge.exec_()
if confirm_merge.clickedButton() == button_yes:
return True
return False
def create_roi(rtss, roi_name, roi_coordinates, data_set, rt_roi_interpreted_type="ORGAN"):
"""
Create new ROI to rtss
:param rtss: dataset of RTSS
:param roi_name: ROIName
:param roi_coordinates: Coordinates of pixels for new ROI
:param data_set: Data Set of selected DICOM image file
:return: rtss, with added ROI
"""
patient_dict_container = PatientDictContainer()
existing_rois = patient_dict_container.get("rois")
roi_exists = False
# This is for adding a new slice to an already existing ROI. For Future Development.
# Check to see if the ROI already exists
for key, value in existing_rois.items():
if value["name"] == roi_name:
roi_exists = True
if not roi_exists:
number_of_contour_points = len(roi_coordinates) / 3
referenced_sop_class_uid = data_set.SOPClassUID
referenced_sop_instance_uid = data_set.SOPInstanceUID
referenced_frame_of_reference_uid = rtss["StructureSetROISequence"].value[0].ReferencedFrameOfReferenceUID
roi_number = rtss["StructureSetROISequence"].value[-1].ROINumber + 1
# Colour TBC
red = random.randint(0, 255)
green = random.randint(0, 255)
blue = random.randint(0, 255)
rgb = [red, green, blue]
# Saving a new StructureSetROISequence
structure_set_sequence = Sequence([Dataset()])
original_structure_set = rtss.StructureSetROISequence
for structure_set in structure_set_sequence:
structure_set.add_new(Tag("ROINumber"), 'IS', roi_number)
structure_set.add_new(Tag("ReferencedFrameOfReferenceUID"), 'UI',
referenced_frame_of_reference_uid)
structure_set.add_new(Tag("ROIName"), 'LO', roi_name)
structure_set.add_new(Tag("ROIGenerationAlgorithm"), 'CS', "")
# Combine old and new structure set
original_structure_set.extend(structure_set_sequence)
rtss.add_new(Tag("StructureSetROISequence"), "SQ", original_structure_set)
# Saving a new ROIContourSequence, ContourSequence, ContourImageSequence
roi_contour_sequence = Sequence([Dataset()])
contour_sequence = Sequence([Dataset()])
contour_image_sequence = Sequence([Dataset()])
# Original File
original_ROI_contour = rtss.ROIContourSequence
# ROI Contour Sequence
for roi_contour in roi_contour_sequence:
roi_contour.add_new(Tag("ROIDisplayColor"), "IS", rgb)
roi_contour.add_new(Tag("ContourSequence"), "SQ", contour_sequence)
# ROI Sequence
for contour in contour_sequence:
# if data_set.get("ReferencedImageSequence"):
contour.add_new(Tag("ContourImageSequence"), "SQ", contour_image_sequence)
# Contour Sequence
for contour_image in contour_image_sequence:
contour_image.add_new(Tag("ReferencedSOPClassUID"), "UI",
referenced_sop_class_uid) # CT Image Storage
contour_image.add_new(Tag("ReferencedSOPInstanceUID"), "UI", referenced_sop_instance_uid)
contour.add_new(Tag("ContourNumber"), "IS", 1)
if not _is_closed_contour(roi_coordinates):
contour.add_new(Tag("ContourGeometricType"), "CS", "OPEN_PLANAR")
contour.add_new(Tag("NumberOfContourPoints"), "IS", number_of_contour_points)
contour.add_new(Tag("ContourData"), "DS", roi_coordinates)
else:
contour.add_new(Tag("ContourGeometricType"), "CS", "CLOSED_PLANAR")
contour.add_new(Tag("NumberOfContourPoints"), "IS", number_of_contour_points-1)
contour.add_new(Tag("ContourData"), "DS", roi_coordinates[0:-3])
roi_contour.add_new(Tag("ReferencedROINumber"), "IS", roi_number)
# Combine original ROIContourSequence with new
original_ROI_contour.extend(roi_contour_sequence)
rtss.add_new(Tag("ROIContourSequence"), "SQ", original_ROI_contour)
# Saving a new RTROIObservationsSequence
RT_ROI_observations_sequence = Sequence([Dataset()])
original_ROI_observation_sequence = rtss.RTROIObservationsSequence
for ROI_observations in RT_ROI_observations_sequence:
# TODO: Check to make sure that there aren't multiple observations per ROI, e.g. increment from existing Observation Numbers?
ROI_observations.add_new(Tag("ObservationNumber"), 'IS', roi_number)
ROI_observations.add_new(Tag("ReferencedROINumber"), 'IS', roi_number)
ROI_observations.add_new(Tag("RTROIInterpretedType"), 'CS', rt_roi_interpreted_type)
original_ROI_observation_sequence.extend(RT_ROI_observations_sequence)
rtss.add_new(Tag("RTROIObservationsSequence"), "SQ", original_ROI_observation_sequence)
else:
# Add contour image data to existing ROI
rtss = add_to_roi(rtss, roi_name, roi_coordinates, data_set)
return rtss
def generate_ROI(self, contours, progress_callback):
"""
Generates new ROIs based on contour data.
:param contours: dictionary of contours to turn into ROIs.
:param progress_callback: signal that receives the current
progress of the loading.
"""
# Initialise variables needed for function
patient_dict_container = PatientDictContainer()
dataset_rtss = patient_dict_container.get("dataset_rtss")
# Get existing ROIs
existing_rois = []
rois = patient_dict_container.get("dataset_rtss")
if rois:
for roi in rois.StructureSetROISequence:
existing_rois.append(roi.ROIName)
# Loop through each SUV level
item_count = len(contours)
current_progress = 60
progress_increment = round((95 - 60) / item_count)
for item in contours:
# Delete ROI if it already exists to recreate it
if item in existing_rois:
dataset_rtss = ROI.delete_roi(dataset_rtss, item)
# Update patient dict container
current_rois = patient_dict_container.get("rois")
keys = []
for key, value in current_rois.items():
if value["name"] == item:
keys.append(key)
for key in keys:
del current_rois[key]
patient_dict_container.set("rois", current_rois)
progress_callback.emit(("Generating ROIs", current_progress))
current_progress += progress_increment
# Loop through each slice
for i in range(len(contours[item])):
slider_id = contours[item][i][0]
dataset = patient_dict_container.dataset[slider_id]
pixlut = patient_dict_container.get("pixluts")
pixlut = pixlut[dataset.SOPInstanceUID]
z_coord = dataset.SliceLocation
# List storing lists that contain all points for a
# contour.
single_array = []
# Loop through each contour
for j in range(len(contours[item][i][1])):
single_array.append([])
# Loop through every point in the contour
for point in contours[item][i][1][j]:
# Convert pixel coordinates to RCS points
rcs_pixels = ROI.pixel_to_rcs(pixlut, round(point[1]),
round(point[0]))
# Append RCS points to the single array
single_array[j].append(rcs_pixels[0])
single_array[j].append(rcs_pixels[1])
single_array[j].append(z_coord)
# Create the ROI(s)
for array in single_array:
rtss = ROI.create_roi(dataset_rtss, item, [{
'coords': array,
'ds': dataset
}], "")
# Save the updated rtss
patient_dict_container.set("dataset_rtss", rtss)
patient_dict_container.set("rois",
ImageLoading.get_roi_info(rtss))
def test_merge_rtss(qtbot, test_object):
"""Test merging rtss. This function creates a new rtss, then merges
the new rtss with the old rtss and asserts that duplicated ROIs
will be overwritten when the other being merged.
:param test_object: test_object function, for accessing the shared
TestStructureTab object.
"""
patient_dict_container = PatientDictContainer()
# Create a new rtss
dataset = patient_dict_container.dataset[0]
rtss_path = Path(patient_dict_container.path).joinpath('rtss.dcm')
new_rtss = create_initial_rtss_from_ct(
dataset, rtss_path,
ImageLoading.get_image_uid_list(patient_dict_container.dataset))
# Set ROIs
rois = ImageLoading.get_roi_info(new_rtss)
patient_dict_container.set("rois", rois)
# Add a new ROI into the new rtss with the name of the first ROI in
# the old rtss
roi_name = test_object.rois.get(1)["name"]
roi_coordinates = [0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0]
new_rtss = create_roi(new_rtss, roi_name, [{
'coords': roi_coordinates,
'ds': dataset
}])
# Add a new ROI with a new name
roi_name = "NewTestROI"
new_rtss = create_roi(new_rtss, roi_name, [{
'coords': roi_coordinates,
'ds': dataset
}])
# Set ROIs
rois = ImageLoading.get_roi_info(new_rtss)
patient_dict_container.set("rois", rois)
patient_dict_container.set("existing_file_rtss",
patient_dict_container.get("file_rtss"))
patient_dict_container.set("dataset_rtss", new_rtss)
# Merge the old and new rtss
structure_tab = StructureTab()
structure_tab.show_modified_indicator()
qtbot.addWidget(structure_tab)
def test_message_window():
messagebox = structure_tab.findChild(QtWidgets.QMessageBox)
assert messagebox is not None
yes_button = messagebox.buttons()[1]
qtbot.mouseClick(yes_button, QtCore.Qt.LeftButton, delay=1)
QtCore.QTimer.singleShot(1000, test_message_window)
structure_tab.save_new_rtss_to_fixed_image_set(auto=True)
merged_rtss = pydicom.read_file(patient_dict_container.get("file_rtss"))
merged_rois = ImageLoading.get_roi_info(merged_rtss)
assert (len(test_object.rois) + 1 == len(merged_rois))
class ActionHandler:
"""
This class is responsible for initializing all of the actions that
will be used by the MainPage and its components. There exists a
1-to-1 relationship between this class and the MainPage. This class
has access to the main page's attributes and components, however
this access should only be used to provide functionality to the
actions defined below. The instance of this class can be given to
the main page's components in order to trigger actions.
"""
def __init__(self, main_page):
self.__main_page = main_page
self.patient_dict_container = PatientDictContainer()
self.is_four_view = False
self.has_image_registration_single = False
self.has_image_registration_four = False
##############################
# Init all actions and icons #
##############################
# Open patient
self.icon_open = QtGui.QIcon()
self.icon_open.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/open_patient_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_open = QtGui.QAction()
self.action_open.setIcon(self.icon_open)
self.action_open.setText("Open new patient")
self.action_open.setIconVisibleInMenu(True)
# Save RTSTRUCT changes action
self.icon_save_structure = QtGui.QIcon()
self.icon_save_structure.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/save_all_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_save_structure = QtGui.QAction()
self.action_save_structure.setIcon(self.icon_save_structure)
self.action_save_structure.setText("Save RTSTRUCT changes")
self.action_save_structure.setIconVisibleInMenu(True)
self.action_save_structure.triggered.connect(self.save_struct_handler)
# Save as Anonymous Action
self.icon_save_as_anonymous = QtGui.QIcon()
self.icon_save_as_anonymous.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/anonlock_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_save_as_anonymous = QtGui.QAction()
self.action_save_as_anonymous.setIcon(self.icon_save_as_anonymous)
self.action_save_as_anonymous.setText("Save as Anonymous")
self.action_save_as_anonymous.triggered.connect(
self.anonymization_handler)
# Exit action
self.action_exit = QtGui.QAction()
self.action_exit.setText("Exit")
self.action_exit.triggered.connect(self.action_exit_handler)
# Zoom Out Action
self.icon_zoom_out = QtGui.QIcon()
self.icon_zoom_out.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/zoom_out_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_zoom_out = QtGui.QAction()
self.action_zoom_out.setIcon(self.icon_zoom_out)
self.action_zoom_out.setIconVisibleInMenu(True)
self.action_zoom_out.setText("Zoom Out")
self.action_zoom_out.triggered.connect(self.zoom_out_handler)
# Zoom In Action
self.icon_zoom_in = QtGui.QIcon()
self.icon_zoom_in.addPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/zoom_in_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_zoom_in = QtGui.QAction()
self.action_zoom_in.setIcon(self.icon_zoom_in)
self.action_zoom_in.setIconVisibleInMenu(True)
self.action_zoom_in.setText("Zoom In")
self.action_zoom_in.triggered.connect(self.zoom_in_handler)
# Transect Action
self.icon_transect = QtGui.QIcon()
self.icon_transect.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/transect_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_transect = QtGui.QAction()
self.action_transect.setIcon(self.icon_transect)
self.action_transect.setIconVisibleInMenu(True)
self.action_transect.setText("Transect")
self.action_transect.triggered.connect(self.transect_handler)
# Add-On Options Action
self.icon_add_ons = QtGui.QIcon()
self.icon_add_ons.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/management_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_add_ons = QtGui.QAction()
self.action_add_ons.setIcon(self.icon_add_ons)
self.action_add_ons.setIconVisibleInMenu(True)
self.action_add_ons.setText("Add-On Options")
self.action_add_ons.triggered.connect(self.add_on_options_handler)
# Switch to Single View Action
self.icon_one_view = QtGui.QIcon()
self.icon_one_view.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/axial_view_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_one_view = QtGui.QAction()
self.action_one_view.setIcon(self.icon_one_view)
self.action_one_view.setIconVisibleInMenu(True)
self.action_one_view.setText("One View")
self.action_one_view.triggered.connect(self.one_view_handler)
# Switch to 4 Views Action
self.icon_four_views = QtGui.QIcon()
self.icon_four_views.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/four_views_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_four_views = QtGui.QAction()
self.action_four_views.setIcon(self.icon_four_views)
self.action_four_views.setIconVisibleInMenu(True)
self.action_four_views.setText("Four Views")
self.action_four_views.triggered.connect(self.four_views_handler)
# Show cut lines
self.icon_cut_lines = QtGui.QIcon()
self.icon_cut_lines.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/cut_line_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_show_cut_lines = QtGui.QAction()
self.action_show_cut_lines.setIcon(self.icon_cut_lines)
self.action_show_cut_lines.setIconVisibleInMenu(True)
self.action_show_cut_lines.setText("Show Cut Lines")
self.action_show_cut_lines.triggered.connect(self.cut_lines_handler)
# Export Pyradiomics Action
self.action_pyradiomics_export = QtGui.QAction()
self.action_pyradiomics_export.setText("Export Pyradiomics")
self.action_pyradiomics_export.triggered.connect(
self.pyradiomics_export_handler)
# Export DVH Action
self.action_dvh_export = QtGui.QAction()
self.action_dvh_export.setText("Export DVH")
self.action_dvh_export.triggered.connect(self.export_dvh_handler)
# Create Windowing menu
self.icon_windowing = QtGui.QIcon()
self.icon_windowing.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/windowing_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.menu_windowing = QtWidgets.QMenu()
self.init_windowing_menu()
self.windowing_window = Windowing(self)
self.windowing_window.done_signal.connect(self.update_views)
# Create Export menu
self.icon_export = QtGui.QIcon()
self.icon_export.addPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/export_purple_icon.png")),
QtGui.QIcon.Normal,
QtGui.QIcon.On,
)
self.menu_export = QtWidgets.QMenu()
self.menu_export.setTitle("Export")
self.menu_export.addAction(self.action_pyradiomics_export)
self.menu_export.addAction(self.action_dvh_export)
# Image Fusion Action
self.icon_image_fusion = QtGui.QIcon()
self.icon_image_fusion.addPixmap(
QtGui.QPixmap(
resource_path(
"res/images/btn-icons/image_fusion_purple_icon.png")),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.action_image_fusion = QtGui.QAction()
self.action_image_fusion.setIcon(self.icon_image_fusion)
self.action_image_fusion.setIconVisibleInMenu(True)
self.action_image_fusion.setText("Image Fusion")
def init_windowing_menu(self):
self.menu_windowing.setIcon(self.icon_windowing)
self.menu_windowing.setTitle("Windowing")
dict_windowing = self.patient_dict_container.get("dict_windowing")
# Get the right order for windowing names
names_ordered = sorted(dict_windowing.keys())
if "Normal" in dict_windowing.keys():
old_index = names_ordered.index("Normal")
names_ordered.insert(0, names_ordered.pop(old_index))
# Create actions for each windowing item
def generate_triggered_handler(text_):
def handler(state):
self.windowing_handler(state, text_)
return handler
windowing_actions = []
for name in names_ordered:
text = str(name)
action_windowing_item = QtGui.QAction(self.menu_windowing)
action_windowing_item.triggered.connect(
generate_triggered_handler(text))
action_windowing_item.setText(text)
windowing_actions.append(action_windowing_item)
# For reasons beyond me, the actions have to be set as a child
# of the windowing menu *and* later be added to the menu as
# well. You can't do one or the other, otherwise the menu won't
# populate. Feel free to try fix (or at least explain why the
# action has to be set as the windowing menu's child twice)
for item in windowing_actions:
self.menu_windowing.addAction(item)
def save_struct_handler(self):
"""
If there are changes to the RTSTRUCT detected,
save the changes to disk.
"""
if self.patient_dict_container.get("rtss_modified"):
self.__main_page.structures_tab.save_new_rtss_to_fixed_image_set()
else:
QtWidgets.QMessageBox.information(
self.__main_page, "File not saved",
"No changes to the RTSTRUCT file detected.")
def zoom_out_handler(self):
self.__main_page.zoom_out(self.is_four_view,
self.has_image_registration_single,
self.has_image_registration_four)
def zoom_in_handler(self):
self.__main_page.zoom_in(self.is_four_view,
self.has_image_registration_single,
self.has_image_registration_four)
def windowing_handler(self, state, text):
"""
Function triggered when a window is selected from the menu.
:param state: Variable not used. Present to be able to use a
lambda function.
:param text: The name of the window selected.
"""
ptct = PTCTDictContainer()
mvd = MovingDictContainer()
if ptct.is_empty() and mvd.is_empty():
windowing_model(text, [True, False, False, False])
self.update_views()
else:
self.windowing_window.set_window(text)
self.windowing_window.show()
def update_views(self):
"""
function to update all dicom views
"""
self.__main_page.update_views(update_3d_window=True)
def anonymization_handler(self):
"""
Function triggered when the Anonymization button is pressed from
the menu.
"""
save_reply = QtWidgets.QMessageBox.information(
self.__main_page.main_window_instance, "Confirmation",
"Are you sure you want to perform anonymization?",
QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
if save_reply == QtWidgets.QMessageBox.Yes:
raw_dvh = self.patient_dict_container.get("raw_dvh")
hashed_path = self.__main_page.call_class.run_anonymization(
raw_dvh)
self.patient_dict_container.set("hashed_path", hashed_path)
# now that the radiomics data can just get copied across...
# maybe skip this?
radiomics_reply = QtWidgets.QMessageBox.information(
self.__main_page.main_window_instance, "Confirmation",
"Anonymization complete. Would you like to perform radiomics?",
QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No)
if radiomics_reply == QtWidgets.QMessageBox.Yes:
self.__main_page.pyradi_trigger.emit(
self.patient_dict_container.path,
self.patient_dict_container.filepaths, hashed_path)
def transect_handler(self):
"""
Function triggered when the Transect button is pressed from the
menu.
"""
if self.is_four_view:
view = self.__main_page.dicom_axial_view.view
slider_id = self.__main_page.dicom_axial_view.slider.value()
else:
view = self.__main_page.dicom_single_view.view
slider_id = self.__main_page.dicom_single_view.slider.value()
dt = self.patient_dict_container.dataset[slider_id]
row_s = dt.PixelSpacing[0]
col_s = dt.PixelSpacing[1]
dt.convert_pixel_data()
pixmap = self.patient_dict_container.get("pixmaps_axial")[slider_id]
self.__main_page.call_class.run_transect(self.__main_page, view,
pixmap,
dt._pixel_array.transpose(),
row_s, col_s)
def add_on_options_handler(self):
self.__main_page.add_on_options_controller.show_add_on_options()
def one_view_handler(self):
self.is_four_view = False
self.__main_page.dicom_view.setCurrentWidget(
self.__main_page.dicom_single_view)
self.__main_page.dicom_single_view.update_view()
if hasattr(self.__main_page, 'image_fusion_view'):
self.has_image_registration_four = False
self.has_image_registration_single = True
if isinstance(self.__main_page.image_fusion_single_view,
ImageFusionAxialView):
self.__main_page.image_fusion_view.setCurrentWidget(
self.__main_page.image_fusion_single_view)
self.__main_page.image_fusion_single_view.update_view()
def four_views_handler(self):
self.is_four_view = True
self.__main_page.dicom_view.setCurrentWidget(
self.__main_page.dicom_four_views)
self.__main_page.dicom_axial_view.update_view()
if hasattr(self.__main_page, 'image_fusion_view'):
self.has_image_registration_four = True
self.has_image_registration_single = False
if isinstance(self.__main_page.image_fusion_view, QStackedWidget):
self.__main_page.image_fusion_view.setCurrentWidget(
self.__main_page.image_fusion_four_views)
self.__main_page.image_fusion_view_axial.update_view()
def cut_lines_handler(self):
self.__main_page.toggle_cut_lines()
def export_dvh_handler(self):
if self.patient_dict_container.has_attribute("raw_dvh"):
self.__main_page.dvh_tab.export_csv()
else:
QtWidgets.QMessageBox.information(
self.__main_page, "Unable to export DVH",
"DVH cannot be exported as there is no DVH present.",
QtWidgets.QMessageBox.Ok)
def pyradiomics_export_handler(self):
self.__main_page.pyradi_trigger.emit(
self.patient_dict_container.path,
self.patient_dict_container.filepaths, '')
def action_exit_handler(self):
QtCore.QCoreApplication.exit(0)
def create_initial_model():
"""
This function initializes all the attributes in the PatientDictContainer model required for the operation of the
main window. This should be called before the main window's components are constructed, but after the initial
values of the PatientDictContainer instance are set (i.e. dataset and filepaths).
"""
##############################
# LOAD PATIENT INFORMATION #
##############################
patient_dict_container = PatientDictContainer()
dataset = patient_dict_container.dataset
filepaths = patient_dict_container.filepaths
patient_dict_container.set("rtss_modified", False)
if ('WindowWidth' in dataset[0]):
if isinstance(dataset[0].WindowWidth, pydicom.valuerep.DSfloat):
window = int(dataset[0].WindowWidth)
elif isinstance(dataset[0].WindowWidth, pydicom.multival.MultiValue):
window = int(dataset[0].WindowWidth[1])
else:
window = int(400)
if ('WindowCenter' in dataset[0]):
if isinstance(dataset[0].WindowCenter, pydicom.valuerep.DSfloat):
level = int(dataset[0].WindowCenter)
elif isinstance(dataset[0].WindowCenter, pydicom.multival.MultiValue):
level = int(dataset[0].WindowCenter[1])
else:
level = int(800)
patient_dict_container.set("window", window)
patient_dict_container.set("level", level)
# Check to see if the imageWindowing.csv file exists
if os.path.exists(resource_path('data/csv/imageWindowing.csv')):
# If it exists, read data from file into the self.dict_windowing variable
dict_windowing = {}
with open(resource_path('data/csv/imageWindowing.csv'),
"r") as fileInput:
next(fileInput)
dict_windowing["Normal"] = [window, level]
for row in fileInput:
# Format: Organ - Scan - Window - Level
items = [item for item in row.split(',')]
dict_windowing[items[0]] = [int(items[2]), int(items[3])]
else:
# If csv does not exist, initialize dictionary with default values
dict_windowing = {
"Normal": [window, level],
"Lung": [1600, -300],
"Bone": [1400, 700],
"Brain": [160, 950],
"Soft Tissue": [400, 800],
"Head and Neck": [275, 900]
}
patient_dict_container.set("dict_windowing", dict_windowing)
pixel_values = convert_raw_data(dataset)
pixmaps = get_pixmaps(pixel_values, window, level)
patient_dict_container.set("pixmaps", pixmaps)
patient_dict_container.set("pixel_values", pixel_values)
basic_info = get_basic_info(dataset[0])
patient_dict_container.set("basic_info", basic_info)
patient_dict_container.set("dict_uid", dict_instanceUID(dataset))
# Set RTSS attributes
if patient_dict_container.has_modality("rtss"):
patient_dict_container.set("file_rtss", filepaths['rtss'])
patient_dict_container.set("dataset_rtss", dataset['rtss'])
dicom_tree_rtss = DicomTree(filepaths['rtss'])
patient_dict_container.set("dict_dicom_tree_rtss",
dicom_tree_rtss.dict)
patient_dict_container.set(
"list_roi_numbers",
ordered_list_rois(patient_dict_container.get("rois")))
patient_dict_container.set("selected_rois", [])
patient_dict_container.set("dict_polygons", {})
# Set RTDOSE attributes
if patient_dict_container.has_modality("rtdose"):
dicom_tree_rtdose = DicomTree(filepaths['rtdose'])
patient_dict_container.set("dict_dicom_tree_rtdose",
dicom_tree_rtdose.dict)
patient_dict_container.set("dose_pixluts", get_dose_pixluts(dataset))
patient_dict_container.set("selected_doses", [])
patient_dict_container.set(
"rx_dose_in_cgray",
1) # This will be overwritten if an RTPLAN is present.
# Set RTPLAN attributes
if patient_dict_container.has_modality("rtplan"):
# the TargetPrescriptionDose is type 3 (optional), so it may not be there
# However, it is preferable to the sum of the beam doses
# DoseReferenceStructureType is type 1 (value is mandatory),
# but it can have a value of ORGAN_AT_RISK rather than TARGET
# in which case there will *not* be a TargetPrescriptionDose
# and even if it is TARGET, that's no guarantee that TargetPrescriptionDose
# will be encoded and have a value
rx_dose_in_cgray = calculate_rx_dose_in_cgray(dataset["rtplan"])
patient_dict_container.set("rx_dose_in_cgray", rx_dose_in_cgray)
dicom_tree_rtplan = DicomTree(filepaths['rtplan'])
patient_dict_container.set("dict_dicom_tree_rtplan",
dicom_tree_rtplan.dict)
def generate_roi(self, contours, progress_callback):
"""
Generates new ROIs based on contour data.
:param contours: dictionary of contours to turn into ROIs.
:param progress_callback: signal to update loading progress
"""
# Initialise variables needed for function
patient_dict_container = PatientDictContainer()
dataset_rtss = patient_dict_container.get("dataset_rtss")
pixmaps = patient_dict_container.get("pixmaps_axial")
slider_min = 0
slider_max = len(pixmaps) - 1
# Get existing ROIs
existing_rois = []
rois = patient_dict_container.get("dataset_rtss")
if rois:
for roi in rois.StructureSetROISequence:
existing_rois.append(roi.ROIName)
# Loop through each isodose level
for item in contours:
# Delete ROI if it already exists to recreate it
if item in existing_rois:
dataset_rtss = ROI.delete_roi(dataset_rtss, item)
# Update patient dict container
current_rois = patient_dict_container.get("rois")
keys = []
for key, value in current_rois.items():
if value["name"] == item:
keys.append(key)
for key in keys:
del current_rois[key]
patient_dict_container.set("rois", current_rois)
# Calculate isodose ROI for each slice, skip if slice has no
# contour data
for i in range(slider_min, slider_max):
if not len(contours[item][i]):
continue
# Get required data for calculating ROI
dataset = patient_dict_container.dataset[i]
pixlut = patient_dict_container.get("pixluts")
pixlut = pixlut[dataset.SOPInstanceUID]
z_coord = dataset.SliceLocation
curr_slice_uid = patient_dict_container.get("dict_uid")[i]
dose_pixluts = patient_dict_container.get("dose_pixluts")
dose_pixluts = dose_pixluts[curr_slice_uid]
# Loop through each contour for each slice.
# Convert the pixel points to RCS points, append z value
single_array = []
# Loop through each contour
for j in range(len(contours[item][i])):
single_array.append([])
# Loop through every second point in the contour
for point in contours[item][i][j][::2]:
# Transform into dose pixel
dose_pixels = [
dose_pixluts[0][int(point[1])],
dose_pixluts[1][int(point[0])]
]
# Transform into RCS pixel
rcs_pixels = ROI.pixel_to_rcs(pixlut,
round(dose_pixels[0]),
round(dose_pixels[1]))
# Append point coordinates to the single array
single_array[j].append(rcs_pixels[0])
single_array[j].append(rcs_pixels[1])
single_array[j].append(z_coord)
# Create the ROI(s)
for array in single_array:
rtss = ROI.create_roi(dataset_rtss, item, [{
'coords': array,
'ds': dataset
}], "DOSE_REGION")
# Save the updated rtss
patient_dict_container.set("dataset_rtss", rtss)
patient_dict_container.set("rois",
ImageLoading.get_roi_info(rtss))
progress_callback.emit(("Writing to RT Structure Set", 85))
class DicomView(QtWidgets.QWidget):
def __init__(self, roi_color=None, iso_color=None):
QtWidgets.QWidget.__init__(self)
self.patient_dict_container = PatientDictContainer()
self.iso_color = iso_color
self.zoom = 1
self.current_slice_number = None
self.dicom_view_layout = QtWidgets.QHBoxLayout()
# Create components
self.slider = QtWidgets.QSlider(QtCore.Qt.Vertical)
self.init_slider()
self.view = QtWidgets.QGraphicsView()
self.init_view()
self.scene = QtWidgets.QGraphicsScene()
# Set layout
self.dicom_view_layout.addWidget(self.view)
self.dicom_view_layout.addWidget(self.slider)
self.setLayout(self.dicom_view_layout)
# Init metadata widgets
self.metadata_layout = QtWidgets.QVBoxLayout(self.view)
self.label_image_id = QtWidgets.QLabel()
self.label_image_pos = QtWidgets.QLabel()
self.label_wl = QtWidgets.QLabel()
self.label_image_size = QtWidgets.QLabel()
self.label_zoom = QtWidgets.QLabel()
self.label_patient_pos = QtWidgets.QLabel()
self.init_metadata()
self.update_view()
def init_slider(self):
"""
Create a slider for the DICOM Image View.
"""
pixmaps = self.patient_dict_container.get("pixmaps")
self.slider.setMinimum(0)
self.slider.setMaximum(len(pixmaps) - 1)
self.slider.setValue(int(len(pixmaps) / 2))
self.slider.setTickPosition(QtWidgets.QSlider.TicksLeft)
self.slider.setTickInterval(1)
self.slider.valueChanged.connect(self.value_changed)
def init_view(self):
"""
Create a view widget for DICOM image.
"""
self.view.setRenderHints(QtGui.QPainter.Antialiasing
| QtGui.QPainter.SmoothPixmapTransform)
background_brush = QtGui.QBrush(QtGui.QColor(0, 0, 0),
QtCore.Qt.SolidPattern)
self.view.setBackgroundBrush(background_brush)
self.view.setGeometry(QtCore.QRect(0, 0, 877, 517))
def init_metadata(self):
"""
Create and place metadata on the view widget.
"""
# Position of the labels on the DICOM view.
self.label_image_id.setAlignment(QtCore.Qt.AlignTop)
self.label_image_pos.setAlignment(QtCore.Qt.AlignTop)
self.label_wl.setAlignment(QtCore.Qt.AlignRight)
self.label_image_size.setAlignment(QtCore.Qt.AlignBottom)
self.label_zoom.setAlignment(QtCore.Qt.AlignBottom)
self.label_patient_pos.setAlignment(QtCore.Qt.AlignRight)
# Set all labels to white
stylesheet = "QLabel { color : white; }"
self.label_image_id.setStyleSheet(stylesheet)
self.label_image_pos.setStyleSheet(stylesheet)
self.label_wl.setStyleSheet(stylesheet)
self.label_image_size.setStyleSheet(stylesheet)
self.label_zoom.setStyleSheet(stylesheet)
self.label_patient_pos.setStyleSheet(stylesheet)
# The following layout was originally accomplished using a QGridLayout with QSpaceItems to anchor the labels
# to the corners of the DICOM view. This caused a reintroduction of the tedious memory issues that were fixed
# with the restructure. The following was rewritten to not use QSpaceItems because they, for reasons unknown,
# caused a memory leak resulting in the entire patient dictionary not being cleared from memory correctly,
# leaving hundreds of additional megabytes unused in memory each time a new patient was opened.
# Create a widget to contain the two top-left labels
top_left_widget = QtWidgets.QWidget()
top_left = QtWidgets.QVBoxLayout(top_left_widget)
top_left.addWidget(self.label_image_id, QtCore.Qt.AlignTop)
top_left.addWidget(self.label_image_pos, QtCore.Qt.AlignTop)
# Create a widget to contain the top-right label
top_right_widget = QtWidgets.QWidget()
top_right = QtWidgets.QVBoxLayout(top_right_widget)
top_right.addWidget(self.label_wl, QtCore.Qt.AlignTop)
# Create a widget to contain the two top widgets
top_widget = QtWidgets.QWidget()
top_widget.setFixedHeight(100)
top = QtWidgets.QHBoxLayout(top_widget)
top.addWidget(top_left_widget, QtCore.Qt.AlignLeft)
top.addWidget(top_right_widget, QtCore.Qt.AlignRight)
# Create a widget to contain the two bottom-left labels
bottom_left_widget = QtWidgets.QWidget()
bottom_left = QtWidgets.QVBoxLayout(bottom_left_widget)
bottom_left.addWidget(self.label_image_size, QtCore.Qt.AlignBottom)
bottom_left.addWidget(self.label_zoom, QtCore.Qt.AlignBottom)
# Create a widget to contain the bottom-right label
bottom_right_widget = QtWidgets.QWidget()
bottom_right = QtWidgets.QVBoxLayout(bottom_right_widget)
bottom_right.addWidget(self.label_patient_pos, QtCore.Qt.AlignBottom)
# Create a widget to contain the two bottom widgets
bottom_widget = QtWidgets.QWidget()
bottom_widget.setFixedHeight(100)
bottom = QtWidgets.QHBoxLayout(bottom_widget)
bottom.addWidget(bottom_left_widget, QtCore.Qt.AlignLeft)
bottom.addWidget(bottom_right_widget, QtCore.Qt.AlignRight)
# Add the bottom and top widgets to the view
self.metadata_layout.addWidget(top_widget, QtCore.Qt.AlignTop)
self.metadata_layout.addStretch()
self.metadata_layout.addWidget(bottom_widget, QtCore.Qt.AlignBottom)
def value_changed(self):
self.update_view()
def update_view(self, zoom_change=False):
"""
Update the view of the DICOM Image.
:param zoom_change: Boolean indicating whether the user wants to change the zoom. False by default.
"""
self.image_display()
if zoom_change:
self.view.setTransform(QtGui.QTransform().scale(
self.zoom, self.zoom))
if self.patient_dict_container.get("selected_rois"):
self.roi_display()
if self.patient_dict_container.get("selected_doses"):
self.isodose_display()
self.update_metadata()
self.view.setScene(self.scene)
def image_display(self):
"""
Update the image to be displayed on the DICOM View.
"""
pixmaps = self.patient_dict_container.get("pixmaps")
slider_id = self.slider.value()
image = pixmaps[slider_id]
label = QtWidgets.QGraphicsPixmapItem(image)
self.scene = QtWidgets.QGraphicsScene()
self.scene.addItem(label)
def roi_display(self):
"""
Display ROI structures on the DICOM Image.
"""
slider_id = self.slider.value()
curr_slice = self.patient_dict_container.get("dict_uid")[slider_id]
selected_rois = self.patient_dict_container.get("selected_rois")
rois = self.patient_dict_container.get("rois")
selected_rois_name = []
for roi in selected_rois:
selected_rois_name.append(rois[roi]['name'])
for roi in selected_rois:
roi_name = rois[roi]['name']
if roi_name not in self.patient_dict_container.get(
"dict_polygons").keys():
new_dict_polygons = self.patient_dict_container.get(
"dict_polygons")
new_dict_polygons[roi_name] = {}
dict_rois_contours = get_contour_pixel(
self.patient_dict_container.get("raw_contour"),
selected_rois_name,
self.patient_dict_container.get("pixluts"), curr_slice)
polygons = self.calc_roi_polygon(roi_name, curr_slice,
dict_rois_contours)
new_dict_polygons[roi_name][curr_slice] = polygons
self.patient_dict_container.set("dict_polygons",
new_dict_polygons)
elif curr_slice not in self.patient_dict_container.get(
"dict_polygons")[roi_name].keys():
new_dict_polygons = self.patient_dict_container.get(
"dict_polygons")
dict_rois_contours = get_contour_pixel(
self.patient_dict_container.get("raw_contour"),
selected_rois_name,
self.patient_dict_container.get("pixluts"), curr_slice)
polygons = self.calc_roi_polygon(roi_name, curr_slice,
dict_rois_contours)
new_dict_polygons[roi_name][curr_slice] = polygons
self.patient_dict_container.set("dict_polygons",
new_dict_polygons)
else:
polygons = self.patient_dict_container.get(
"dict_polygons")[roi_name][curr_slice]
color = self.patient_dict_container.get("roi_color_dict")[roi]
with open(resource_path('src/data/line&fill_configuration'),
'r') as stream:
elements = stream.readlines()
if len(elements) > 0:
roi_line = int(elements[0].replace('\n', ''))
roi_opacity = int(elements[1].replace('\n', ''))
line_width = float(elements[4].replace('\n', ''))
else:
roi_line = 1
roi_opacity = 10
line_width = 2.0
stream.close()
roi_opacity = int((roi_opacity / 100) * 255)
color.setAlpha(roi_opacity)
pen = self.get_qpen(color, roi_line, line_width)
for i in range(len(polygons)):
self.scene.addPolygon(polygons[i], pen, QtGui.QBrush(color))
def isodose_display(self):
"""
Display isodoses on the DICOM Image.
"""
slider_id = self.slider.value()
curr_slice_uid = self.patient_dict_container.get("dict_uid")[slider_id]
z = self.patient_dict_container.dataset[
slider_id].ImagePositionPatient[2]
dataset_rtdose = self.patient_dict_container.dataset['rtdose']
grid = get_dose_grid(dataset_rtdose, float(z))
if not (grid == []):
x, y = np.meshgrid(np.arange(grid.shape[1]),
np.arange(grid.shape[0]))
# Instantiate the isodose generator for this slice
isodosegen = cntr.Cntr(x, y, grid)
# sort selected_doses in ascending order so that the high dose isodose washes
# paint over the lower dose isodose washes
for sd in sorted(
self.patient_dict_container.get("selected_doses")):
dose_level = sd * self.patient_dict_container.get("rx_dose_in_cgray") / \
(dataset_rtdose.DoseGridScaling * 10000)
contours = isodosegen.trace(dose_level)
contours = contours[:len(contours) // 2]
polygons = self.calc_dose_polygon(
self.patient_dict_container.get("dose_pixluts")
[curr_slice_uid], contours)
brush_color = self.iso_color[sd]
with open(resource_path('src/data/line&fill_configuration'),
'r') as stream:
elements = stream.readlines()
if len(elements) > 0:
iso_line = int(elements[2].replace('\n', ''))
iso_opacity = int(elements[3].replace('\n', ''))
line_width = float(elements[4].replace('\n', ''))
else:
iso_line = 2
iso_opacity = 5
line_width = 2.0
stream.close()
iso_opacity = int((iso_opacity / 100) * 255)
brush_color.setAlpha(iso_opacity)
pen_color = QtGui.QColor(brush_color.red(),
brush_color.green(),
brush_color.blue())
pen = self.get_qpen(pen_color, iso_line, line_width)
for i in range(len(polygons)):
self.scene.addPolygon(polygons[i], pen,
QtGui.QBrush(brush_color))
def update_metadata(self):
"""
Update metadata displayed on the DICOM Image view.
"""
# Retrieve dictionary from the dataset of the slice
id = self.slider.value()
dataset = self.patient_dict_container.dataset[id]
# Information to display
self.current_slice_number = dataset['InstanceNumber'].value
total_slices = len(self.patient_dict_container.get("pixmaps"))
row_img = dataset['Rows'].value
col_img = dataset['Columns'].value
patient_pos = dataset['PatientPosition'].value
window = self.patient_dict_container.get("window")
level = self.patient_dict_container.get("level")
slice_pos = dataset['SliceLocation'].value
# Update labels
self.label_image_id.setText(
"Image: %s / %s" %
(str(self.current_slice_number), str(total_slices)))
self.label_image_pos.setText("Position: %s mm" % (str(slice_pos)))
self.label_wl.setText("W/L: %s/%s" % (str(window), str(level)))
self.label_image_size.setText("Image Size: %sx%spx" %
(str(row_img), str(col_img)))
self.label_zoom.setText("Zoom: " + "{:.2f}".format(self.zoom * 100) +
"%")
self.label_patient_pos.setText("Patient Position: %s" %
(str(patient_pos)))
def calc_roi_polygon(self, curr_roi, curr_slice, dict_rois_contours):
"""
Calculate a list of polygons to display for a given ROI and a given slice.
:param curr_roi:
the ROI structure
:param curr_slice:
the current slice
:return: List of polygons of type QPolygonF.
"""
# TODO Implement support for showing "holes" in contours.
# Possible process for this is:
# 1. Calculate the areas of each contour on the slice
# https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates
# 2. Compare each contour to the largest contour by area to determine if it is contained entirely within the
# largest contour.
# https://stackoverflow.com/questions/4833802/check-if-polygon-is-inside-a-polygon
# 3. If the polygon is contained, use QPolygonF.subtracted(QPolygonF) to subtract the smaller "hole" polygon
# from the largest polygon, and then remove the polygon from the list of polygons to be displayed.
# This process should provide fast and reliable results, however it should be noted that this method may fall
# apart in a situation where there are multiple "large" polygons, each with their own hole in it. An appropriate
# solution to that may be to compare every contour against one another and determine which ones have holes
# encompassed entirely by them, and then subtract each hole from the larger polygon and delete the smaller
# holes. This second solution would definitely lead to more accurate representation of contours, but could
# possibly be too slow to be viable.
list_polygons = []
pixel_list = dict_rois_contours[curr_roi][curr_slice]
for i in range(len(pixel_list)):
list_qpoints = []
contour = pixel_list[i]
for point in contour:
curr_qpoint = QtCore.QPoint(point[0], point[1])
list_qpoints.append(curr_qpoint)
curr_polygon = QtGui.QPolygonF(list_qpoints)
list_polygons.append(curr_polygon)
return list_polygons
def calc_dose_polygon(self, dose_pixluts, contours):
"""
Calculate a list of polygons to display for a given isodose.
:param dose_pixluts:
lookup table (LUT) to get the image pixel values
:param contours:
trace outline of the isodose to be displayed
:return: List of polygons of type QPolygonF.
"""
list_polygons = []
for contour in contours:
list_qpoints = []
# Slicing controls how many points considered for visualization
# Essentially effects sharpness of edges, fewer points equals "smoother" edges
for point in contour[::2]:
curr_qpoint = QtCore.QPoint(dose_pixluts[0][int(point[0])],
dose_pixluts[1][int(point[1])])
list_qpoints.append(curr_qpoint)
curr_polygon = QtGui.QPolygonF(list_qpoints)
list_polygons.append(curr_polygon)
return list_polygons
def get_qpen(self, color, style=1, widthF=1):
"""
The color and style for ROI structure and isodose display.
:param color:
Color of the region. QColor type.
:param style:
Style of the contour line. NoPen: 0 SolidLine: 1 DashLine: 2 DotLine: 3 DashDotLine: 4 DashDotDotLine: 5
:param widthF:
Width of the contour line.
:return: QPen object.
"""
pen = QtGui.QPen(color)
pen.setStyle(style)
pen.setWidthF(widthF)
return pen
def zoom_in(self):
self.zoom *= 1.05
self.update_view(zoom_change=True)
def zoom_out(self):
self.zoom /= 1.05
self.update_view(zoom_change=True)
class DVHTab(QtWidgets.QWidget):
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.patient_dict_container = PatientDictContainer()
self.dvh_calculated = self.patient_dict_container.has_attribute(
"raw_dvh")
self.raw_dvh = None
self.dvh_x_y = None
self.plot = None
self.selected_rois = self.patient_dict_container.get("selected_rois")
self.dvh_tab_layout = QtWidgets.QVBoxLayout()
# Construct the layout based on whether or not the DVH has already been calculated.
if self.dvh_calculated:
self.init_layout_dvh()
else:
self.init_layout_no_dvh()
self.setLayout(self.dvh_tab_layout)
def init_layout_dvh(self):
self.raw_dvh = self.patient_dict_container.get("raw_dvh")
self.dvh_x_y = self.patient_dict_container.get("dvh_x_y")
self.plot = self.plot_dvh()
widget_plot = FigureCanvas(self.plot)
button_export = QtWidgets.QPushButton("Export DVH")
button_export.clicked.connect(self.export_csv)
self.dvh_tab_layout.setAlignment(QtCore.Qt.Alignment())
self.dvh_tab_layout.addWidget(widget_plot)
self.dvh_tab_layout.addWidget(button_export,
alignment=QtCore.Qt.AlignRight)
def init_layout_no_dvh(self):
button_calc_dvh = QtWidgets.QPushButton("Calculate DVH")
button_calc_dvh.clicked.connect(self.prompt_calc_dvh)
self.dvh_tab_layout.setAlignment(QtCore.Qt.AlignCenter)
self.dvh_tab_layout.addWidget(button_calc_dvh)
def clear_layout(self):
for i in reversed(range(self.dvh_tab_layout.count())):
self.dvh_tab_layout.itemAt(i).widget().setParent(None)
def plot_dvh(self):
"""
:return: DVH plot using Matplotlib library.
"""
# Initialisation of the plots
fig, ax = plt.subplots()
fig.subplots_adjust(0.1, 0.15, 1, 1)
# Maximum value for x axis
max_xlim = 0
# Plot for all the ROIs selected in the left column of the window
for roi in self.selected_rois:
dvh = self.raw_dvh[int(roi)]
# Plot only the ROIs whose volume is non equal to 0
if dvh.volume != 0:
# Bincenters, obtained from the dvh object, give the x axis values
# (Doses originally in Gy unit)
bincenters = self.dvh_x_y[roi]['bincenters']
#print(self.dvh_x_y[roi])
# Counts, obtained from the dvh object, give the y axis values
# (values between 0 and dvh.volume)
counts = self.dvh_x_y[roi]['counts']
# Color of the line is the same as the color shown in the left column of the window
color = self.patient_dict_container.get("roi_color_dict")[roi]
color_R = color.red() / 255
color_G = color.green() / 255
color_B = color.blue() / 255
plt.plot(100 * bincenters,
100 * counts / dvh.volume,
label=dvh.name,
color=[color_R, color_G, color_B])
# Update the maximum value for x axis (usually different between ROIs)
if (100 * bincenters[-1]) > max_xlim:
max_xlim = 100 * bincenters[-1]
plt.xlabel('Dose [%s]' % 'cGy')
plt.ylabel('Volume [%s]' % '%')
if dvh.name:
plt.legend(loc='lower center', bbox_to_anchor=(0, 1, 5, 5))
# Set the range values for x and y axis
ax.set_ylim([0, 105])
ax.set_xlim([0, max_xlim + 3])
# Create the grids on the plot
major_ticks_y = np.arange(0, 105, 20)
minor_ticks_y = np.arange(0, 105, 5)
major_ticks_x = np.arange(0, max_xlim + 250, 1000)
minor_ticks_x = np.arange(0, max_xlim + 250, 250)
ax.set_xticks(major_ticks_x)
ax.set_xticks(minor_ticks_x, minor=True)
ax.set_yticks(major_ticks_y)
ax.set_yticks(minor_ticks_y, minor=True)
ax.grid(which='minor', alpha=0.2)
ax.grid(which='major', alpha=0.5)
# Add the legend at the bottom left of the graph
if len(self.selected_rois) != 0:
ax.legend(loc='upper left', bbox_to_anchor=(-0.1, -0.15), ncol=4)
plt.subplots_adjust(bottom=0.3)
return fig
def prompt_calc_dvh(self):
choice = QtWidgets.QMessageBox.question(
self, "Calculate DVHs?",
"Would you like to calculate DVHs? This may"
" take up to several minutes on some systems.",
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if choice == QtWidgets.QMessageBox.Yes:
progress_window = CalculateDVHProgressWindow(
self,
QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint)
progress_window.signal_dvh_calculated.connect(
self.dvh_calculation_finished)
progress_window.exec_()
def dvh_calculation_finished(self):
# Clear the screen
self.clear_layout()
self.dvh_calculated = True
self.init_layout_dvh()
def update_plot(self):
if self.dvh_calculated:
# Get new list of selected rois that have DVHs calculated
self.selected_rois = [
roi for roi in self.patient_dict_container.get("selected_rois")
if roi in self.raw_dvh.keys()
]
# Clear the current layout
self.clear_layout()
# If the DVH has become outdated, show the user an indicator advising them such.
if self.patient_dict_container.get("dvh_outdated"):
self.display_outdated_indicator()
# Re-draw the plot and add to layout
self.init_layout_dvh()
def export_csv(self):
path = self.patient_dict_container.path
basic_info = self.patient_dict_container.get("basic_info")
if not os.path.isdir(path + '/CSV'):
os.mkdir(path + '/CSV')
dvh2csv(self.raw_dvh, path + "/CSV/", 'DVH_' + basic_info['id'],
basic_info['id'])
save_reply = QtWidgets.QMessageBox.information(
self, "Message",
"The DVH Data was saved successfully in your directory!",
QtWidgets.QMessageBox.Ok)
def display_outdated_indicator(self):
self.modified_indicator_widget = QtWidgets.QWidget()
self.modified_indicator_widget.setContentsMargins(8, 5, 8, 5)
#self.modified_indicator_widget.setFixedHeight(35)
modified_indicator_layout = QtWidgets.QHBoxLayout()
modified_indicator_layout.setAlignment(QtCore.Qt.AlignLeft)
modified_indicator_icon = QtWidgets.QLabel()
modified_indicator_icon.setPixmap(
QtGui.QPixmap(
resource_path("src/res/images/btn-icons/alert_icon.png")))
modified_indicator_layout.addWidget(modified_indicator_icon)
modified_indicator_text = QtWidgets.QLabel(
"Contours have been modified since DVH calculation. Some DVHs may "
"now be out of date.")
modified_indicator_text.setStyleSheet("color: red")
modified_indicator_layout.addWidget(modified_indicator_text)
self.modified_indicator_widget.setLayout(modified_indicator_layout)
self.dvh_tab_layout.addWidget(self.modified_indicator_widget,
QtCore.Qt.AlignTop)
class DicomView(QtWidgets.QWidget):
def __init__(self, roi_color=None, iso_color=None, cut_line_color=None):
QtWidgets.QWidget.__init__(self)
self.patient_dict_container = PatientDictContainer()
self.iso_color = iso_color
self.roi_color = roi_color
self.zoom = INITIAL_ONE_VIEW_ZOOM
self.current_slice_number = None
self.horizontal_view = None
self.vertical_view = None
self.cut_lines_color = cut_line_color
self.dicom_view_layout = QtWidgets.QHBoxLayout()
# Create components
self.slider = QtWidgets.QSlider(QtCore.Qt.Vertical)
self.init_slider()
self.view = QtWidgets.QGraphicsView()
self.init_view()
self.scene = QtWidgets.QGraphicsScene()
# Set layout
self.dicom_view_layout.addWidget(self.view)
self.dicom_view_layout.addWidget(self.slider)
self.setLayout(self.dicom_view_layout)
def init_slider(self):
"""
Create a slider for the DICOM Image View.
"""
pixmaps = self.patient_dict_container.get("pixmaps_" + self.slice_view)
self.slider.setMinimum(0)
self.slider.setMaximum(len(pixmaps) - 1)
self.slider.setValue(int(len(pixmaps) / 2))
self.slider.setTickPosition(QtWidgets.QSlider.TicksLeft)
self.slider.setTickInterval(1)
self.slider.valueChanged.connect(self.value_changed)
def init_view(self):
"""
Create a view widget for DICOM image.
"""
self.view.setRenderHints(
QtGui.QPainter.Antialiasing | QtGui.QPainter.SmoothPixmapTransform)
background_brush = QtGui.QBrush(
QtGui.QColor(0, 0, 0), QtCore.Qt.SolidPattern)
self.view.setBackgroundBrush(background_brush)
def value_changed(self):
self.update_view()
if self.horizontal_view is not None and self.vertical_view is not None:
self.horizontal_view.update_view()
self.vertical_view.update_view()
def update_view(self, zoom_change=False):
"""
Update the view of the DICOM Image.
:param zoom_change: Boolean indicating whether the user wants to change the zoom. False by default.
"""
self.image_display()
# Update roi colours if they are not explicitly set to None
if self.roi_color is not None:
self.roi_color = self.patient_dict_container.get("roi_color_dict")
# If roi colours are set and rois are selected then update the display
if self.roi_color and self.patient_dict_container.get("selected_rois"):
self.roi_display()
# If isodose colours are set and doses are selected then update the display
if self.iso_color and self.patient_dict_container.get("selected_doses"):
self.isodose_display()
if zoom_change:
self.view.setTransform(
QtGui.QTransform().scale(self.zoom, self.zoom))
self.view.setScene(self.scene)
def image_display(self):
"""
Update the image to be displayed on the DICOM View.
"""
pixmaps = self.patient_dict_container.get("pixmaps_" + self.slice_view)
slider_id = self.slider.value()
image = pixmaps[slider_id]
label = QtWidgets.QGraphicsPixmapItem(image)
self.scene = GraphicsScene(
label, self.horizontal_view, self.vertical_view)
def draw_roi_polygons(self, roi_id, polygons, roi_color=None):
"""
Draw ROI polygons on the image slice
:param roi_id: ROI number
:param polygons: List of ROI polygons
:param roi_color: colors for ROIs used when displaying selected rois in
manipulate ROI window
"""
if roi_color is None:
color = self.roi_color[roi_id]
else:
color = roi_color[roi_id]
with open(data_path('line&fill_configuration'), 'r') as stream:
elements = stream.readlines()
if len(elements) > 0:
roi_line = int(elements[0].replace('\n', ''))
roi_opacity = int(elements[1].replace('\n', ''))
line_width = float(elements[4].replace('\n', ''))
else:
roi_line = 1
roi_opacity = 10
line_width = 2.0
stream.close()
roi_opacity = int((roi_opacity / 100) * 255)
color.setAlpha(roi_opacity)
pen_color = QtGui.QColor(color.red(), color.green(), color.blue())
pen = self.get_qpen(pen_color, roi_line, line_width)
for i in range(len(polygons)):
self.scene.addPolygon(polygons[i], pen, QtGui.QBrush(color))
def get_qpen(self, color, style=1, widthF=1.):
"""
The color and style for ROI structure and isodose display.
:param color:
Color of the region. QColor type.
:param style:
Style of the contour line. NoPen: 0 SolidLine: 1 DashLine: 2 DotLine: 3 DashDotLine: 4 DashDotDotLine: 5
:param widthF:
Width of the contour line.
:return: QPen object.
"""
pen = QtGui.QPen(color)
pen.setStyle(QtCore.Qt.PenStyle(style))
pen.setWidthF(widthF)
return pen
def zoom_in(self):
self.zoom *= 1.05
self.update_view(zoom_change=True)
def zoom_out(self):
self.zoom /= 1.05
self.update_view(zoom_change=True)
def set_views(self, horizontal_view, vertical_view):
"""
Set the views represented by the horizontal and vertical cut lines respectively
"""
self.horizontal_view = horizontal_view
self.vertical_view = vertical_view
self.update_view()
def set_slider_value(self, value):
"""
Set the value of the slider of this view
"""
self.slider.setValue(value*self.slider.maximum())
self.update_view()
class DVHTab(QtWidgets.QWidget):
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.patient_dict_container = PatientDictContainer()
self.dvh_calculated = self.patient_dict_container.has_attribute(
"raw_dvh")
self.rt_dose = self.patient_dict_container.dataset['rtdose']
self.raw_dvh = None
self.dvh_x_y = None
self.plot = None
self.selected_rois = self.patient_dict_container.get("selected_rois")
self.dvh_tab_layout = QtWidgets.QVBoxLayout()
try:
# Import the DVH from RT Dose
self.import_rtdose()
except (AttributeError, KeyError):
# Construct the layout based on whether or not the DVH has
# already been calculated.
# TODO: convert to logging
print("DVH data not in RT Dose.")
if self.dvh_calculated:
self.init_layout_dvh()
else:
self.init_layout_no_dvh()
self.setLayout(self.dvh_tab_layout)
def init_layout_dvh(self):
"""
Initialise the DVH tab's layout when DVH data exists.
"""
self.raw_dvh = self.patient_dict_container.get("raw_dvh")
self.dvh_x_y = self.patient_dict_container.get("dvh_x_y")
self.plot = self.plot_dvh()
widget_plot = FigureCanvas(self.plot)
button_layout = QtWidgets.QHBoxLayout()
button_export = QtWidgets.QPushButton("Export DVH to CSV")
button_export.clicked.connect(self.export_csv)
button_layout.addWidget(button_export)
# Added Recalculate button
button_calc_dvh = QtWidgets.QPushButton("Recalculate DVH")
button_calc_dvh.clicked.connect(self.prompt_calc_dvh)
button_layout.addWidget(button_calc_dvh)
self.dvh_tab_layout.setAlignment(QtCore.Qt.Alignment())
self.dvh_tab_layout.addWidget(widget_plot)
self.dvh_tab_layout.addLayout(button_layout)
def init_layout_no_dvh(self):
"""
Initialise the DVH tab's layout when DVH data does not exist.
"""
button_calc_dvh = QtWidgets.QPushButton("Calculate DVH")
button_calc_dvh.clicked.connect(self.prompt_calc_dvh)
self.dvh_tab_layout.setAlignment(QtCore.Qt.AlignCenter
| QtCore.Qt.AlignCenter)
self.dvh_tab_layout.addWidget(button_calc_dvh)
def clear_layout(self):
"""
Clear the layout of the DVH tab.
"""
for i in reversed(range(self.dvh_tab_layout.count())):
item = self.dvh_tab_layout.itemAt(i)
if item.widget():
item.widget().setParent(None)
else:
for j in reversed(range(item.count())):
item.itemAt(j).widget().setParent(None)
def plot_dvh(self):
"""
:return: DVH plot using Matplotlib library.
"""
# Initialisation of the plots
fig, ax = plt.subplots()
fig.subplots_adjust(0.1, 0.15, 1, 1)
# Maximum value for x axis
max_xlim = 0
# Plot for all the ROIs selected in the left column of the window
for roi in self.selected_rois:
dvh = self.raw_dvh[int(roi)]
# Plot only the ROIs whose volume is non equal to 0
if dvh.volume != 0:
# Bincenters, obtained from the dvh object, give the x axis values
# (Doses originally in Gy unit)
bincenters = self.dvh_x_y[roi]['bincenters']
# print(self.dvh_x_y[roi])
# Counts, obtained from the dvh object, give the y axis values
# (values between 0 and dvh.volume)
counts = self.dvh_x_y[roi]['counts']
# Color of the line is the same as the color shown in the left column of the window
color = self.patient_dict_container.get("roi_color_dict")[roi]
color_R = color.red() / 255
color_G = color.green() / 255
color_B = color.blue() / 255
plt.plot(100 * bincenters,
100 * counts / dvh.volume,
label=dvh.name,
color=[color_R, color_G, color_B])
# Update the maximum value for x axis (usually different between ROIs)
if (100 * bincenters[-1]) > max_xlim:
max_xlim = 100 * bincenters[-1]
plt.xlabel('Dose [%s]' % 'cGy')
plt.ylabel('Volume [%s]' % '%')
if dvh.name:
plt.legend(loc='lower center', bbox_to_anchor=(0, 1, 5, 5))
# Set the range values for x and y axis
ax.set_ylim([0, 105])
ax.set_xlim([0, max_xlim + 3])
# Create the grids on the plot
major_ticks_y = np.arange(0, 105, 20)
minor_ticks_y = np.arange(0, 105, 5)
major_ticks_x = np.arange(0, max_xlim + 250, 1000)
minor_ticks_x = np.arange(0, max_xlim + 250, 250)
ax.set_xticks(major_ticks_x)
ax.set_xticks(minor_ticks_x, minor=True)
ax.set_yticks(major_ticks_y)
ax.set_yticks(minor_ticks_y, minor=True)
ax.grid(which='minor', alpha=0.2)
ax.grid(which='major', alpha=0.5)
# Add the legend at the bottom left of the graph
if len(self.selected_rois) != 0:
ax.legend(loc='upper left', bbox_to_anchor=(-0.1, -0.15), ncol=4)
plt.subplots_adjust(bottom=0.3)
return fig
def prompt_calc_dvh(self):
"""
Prompt for DVH calculation.
"""
if platform.system() == "Linux":
choice = \
QtWidgets.QMessageBox.question(
self, "Calculate DVHs?",
"Would you like to (re)calculate DVHs?",
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if choice == QtWidgets.QMessageBox.Yes:
progress_window = \
CalculateDVHProgressWindow(
self,
QtCore.Qt.WindowTitleHint |
QtCore.Qt.WindowCloseButtonHint)
progress_window.signal_dvh_calculated.connect(
self.dvh_calculation_finished)
self.patient_dict_container.set("dvh_outdated", False)
progress_window.exec_()
self.export_rtdose()
else:
stylesheet_path = ""
# Select appropriate style sheet
if platform.system() == 'Darwin':
stylesheet_path = Path.cwd().joinpath('res', 'stylesheet.qss')
else:
stylesheet_path = Path.cwd().joinpath(
'res', 'stylesheet-win-linux.qss')
# Create a message box and add attributes
mb = QtWidgets.QMessageBox()
mb.setIcon(QtWidgets.QMessageBox.Question)
mb.setWindowTitle("Calculate DVHs?")
mb.setText("Would you like to (re)calculate DVHs?")
button_no = QtWidgets.QPushButton("No")
button_yes = QtWidgets.QPushButton("Yes")
""" We want the buttons 'No' & 'Yes' to be displayed in that exact order. QMessageBox displays buttons in
respect to their assigned roles. (0 first, then 0 and so on) 'AcceptRole' is 0 and 'RejectRole' is 1
thus by counterintuitively assigning 'No' to 'AcceptRole' and 'Yes' to 'RejectRole' the buttons are
positioned as desired.
"""
mb.addButton(button_no, QtWidgets.QMessageBox.AcceptRole)
mb.addButton(button_yes, QtWidgets.QMessageBox.RejectRole)
# Apply stylesheet to the message box and add icon to the window
mb.setStyleSheet(open(stylesheet_path).read())
mb.setWindowIcon(
QtGui.QIcon(
resource_path(Path.cwd().joinpath('res', 'images',
'btn-icons',
'onkodicom_icon.png'))))
mb.exec_()
if mb.clickedButton() == button_yes:
progress_window = CalculateDVHProgressWindow(
self, QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowCloseButtonHint)
progress_window.signal_dvh_calculated.connect(
self.dvh_calculation_finished)
self.patient_dict_container.set("dvh_outdated", False)
progress_window.exec_()
self.export_rtdose()
def dvh_calculation_finished(self):
# Clear the screen
self.clear_layout()
self.dvh_calculated = True
self.init_layout_dvh()
def update_plot(self):
if self.dvh_calculated:
# Get new list of selected rois that have DVHs calculated
self.selected_rois = [
roi for roi in self.patient_dict_container.get("selected_rois")
if roi in self.raw_dvh.keys()
]
# Clear the current layout
self.clear_layout()
# If the DVH has become outdated, show the user an indicator advising them such.
if self.patient_dict_container.get("dvh_outdated"):
self.display_outdated_indicator()
# Re-draw the plot and add to layout
self.init_layout_dvh()
def export_csv(self):
path = self.patient_dict_container.path
basic_info = self.patient_dict_container.get("basic_info")
if not os.path.isdir(path + '/CSV'):
os.mkdir(path + '/CSV')
dvh2csv(self.raw_dvh, path + "/CSV/", 'DVH_' + basic_info['id'],
basic_info['id'])
QtWidgets.QMessageBox.information(
self, "Message",
"The DVH Data was saved successfully in your directory!",
QtWidgets.QMessageBox.Ok)
def export_rtdose(self):
"""
Exports DVH data into the RT Dose file in the dataset directory.
"""
dvh2rtdose(self.raw_dvh)
QtWidgets.QMessageBox.information(
self, "Message",
"The DVH Data was saved successfully in your directory!",
QtWidgets.QMessageBox.Ok)
def import_rtdose(self):
"""
Import DVH data from an RT Dose.
"""
# Get DVH data
result = rtdose2dvh()
# If there is DVH data
if bool(result):
incomplete = result["diff"]
result.pop("diff")
dvh_x_y = ImageLoading.converge_to_0_dvh(result)
self.patient_dict_container.set("raw_dvh", result)
self.patient_dict_container.set("dvh_x_y", dvh_x_y)
# If incomplete, tell the user about this
if incomplete:
self.patient_dict_container.set("dvh_outdated", True)
self.display_outdated_indicator()
# Initialise the display
self.dvh_calculation_finished()
else:
result.pop("diff")
self.init_layout_no_dvh()
def display_outdated_indicator(self):
self.modified_indicator_widget = QtWidgets.QWidget()
self.modified_indicator_widget.setContentsMargins(8, 5, 8, 5)
# self.modified_indicator_widget.setFixedHeight(35)
modified_indicator_layout = QtWidgets.QHBoxLayout()
modified_indicator_layout.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignLeft)
modified_indicator_icon = QtWidgets.QLabel()
modified_indicator_icon.setPixmap(
QtGui.QPixmap(
resource_path("res/images/btn-icons/alert_icon.png")))
modified_indicator_layout.addWidget(modified_indicator_icon)
modified_indicator_text = QtWidgets.QLabel(
"Contours have been modified since DVH calculation. Some DVHs may "
"now be out of date.")
modified_indicator_text.setStyleSheet("color: red")
modified_indicator_layout.addWidget(modified_indicator_text)
self.modified_indicator_widget.setLayout(modified_indicator_layout)
self.dvh_tab_layout.addWidget(self.modified_indicator_widget,
QtCore.Qt.AlignTop | QtCore.Qt.AlignTop)
class UIImageFusionWindow(object):
image_fusion_info_initialized = QtCore.Signal(object)
def setup_ui(self, open_image_fusion_select_instance):
"""Sets up a UI"""
if platform.system() == 'Darwin':
self.stylesheet_path = "res/stylesheet.qss"
else:
self.stylesheet_path = "res/stylesheet-win-linux.qss"
window_icon = QIcon()
window_icon.addPixmap(QPixmap(resource_path("res/images/icon.ico")),
QIcon.Normal, QIcon.Off)
open_image_fusion_select_instance.setObjectName(
"OpenPatientWindowInstance")
open_image_fusion_select_instance.setWindowIcon(window_icon)
open_image_fusion_select_instance.resize(840, 530)
# Create a vertical box for containing the other elements and layouts
self.open_patient_window_instance_vertical_box = QVBoxLayout()
self.open_patient_window_instance_vertical_box.setObjectName(
"OpenPatientWindowInstanceVerticalBox")
# Create a label to prompt the user to enter the path to the
# directory that contains the DICOM files
self.open_patient_directory_prompt = QLabel()
self.open_patient_directory_prompt.setObjectName(
"OpenPatientDirectoryPrompt")
self.open_patient_directory_prompt.setAlignment(Qt.AlignLeft)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_directory_prompt)
# Create a horizontal box to hold the input box for the directory
# and the choose button
self.open_patient_directory_input_horizontal_box = QHBoxLayout()
self.open_patient_directory_input_horizontal_box.setObjectName(
"OpenPatientDirectoryInputHorizontalBox")
# Create a textbox to contain the path to the directory that contains
# the DICOM files
self.open_patient_directory_input_box = \
UIImageFusionWindowDragAndDropEvent(self)
self.open_patient_directory_input_box.setObjectName(
"OpenPatientDirectoryInputBox")
self.open_patient_directory_input_box.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_directory_input_box.returnPressed.connect(
self.scan_directory_for_patient)
self.open_patient_directory_input_horizontal_box.addWidget(
self.open_patient_directory_input_box)
# Create a choose button to open the file dialog
self.open_patient_directory_choose_button = QPushButton()
self.open_patient_directory_choose_button.setObjectName(
"OpenPatientDirectoryChooseButton")
self.open_patient_directory_choose_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_directory_choose_button.resize(
self.open_patient_directory_choose_button.sizeHint().width(),
self.open_patient_directory_input_box.height())
self.open_patient_directory_choose_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.open_patient_directory_input_horizontal_box.addWidget(
self.open_patient_directory_choose_button)
self.open_patient_directory_choose_button.clicked.connect(
self.choose_button_clicked)
# Create a widget to hold the input fields
self.open_patient_directory_input_widget = QWidget()
self.open_patient_directory_input_horizontal_box.setStretch(0, 4)
self.open_patient_directory_input_widget.setLayout(
self.open_patient_directory_input_horizontal_box)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_directory_input_widget)
# Create a horizontal box to hold the stop button and direction to
# the user on where to select the patient
self.open_patient_appear_prompt_and_stop_horizontal_box = QHBoxLayout()
self.open_patient_appear_prompt_and_stop_horizontal_box.setObjectName(
"OpenPatientAppearPromptAndStopHorizontalBox")
# Create a label to show direction on where the files will appear
self.open_patient_directory_appear_prompt = QLabel()
self.open_patient_directory_appear_prompt.setObjectName(
"OpenPatientDirectoryAppearPrompt")
self.open_patient_directory_appear_prompt.setAlignment(Qt.AlignLeft)
self.open_patient_appear_prompt_and_stop_horizontal_box.addWidget(
self.open_patient_directory_appear_prompt)
self.open_patient_appear_prompt_and_stop_horizontal_box.addStretch(1)
# Create a button to stop searching
self.open_patient_window_stop_button = QPushButton()
self.open_patient_window_stop_button.setObjectName(
"OpenPatientWindowStopButton")
self.open_patient_window_stop_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_window_stop_button.resize(
self.open_patient_window_stop_button.sizeHint().width(),
self.open_patient_window_stop_button.sizeHint().height())
self.open_patient_window_stop_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.open_patient_window_stop_button.clicked.connect(
self.stop_button_clicked)
self.open_patient_window_stop_button.setProperty(
"QPushButtonClass", "fail-button")
self.open_patient_window_stop_button.setVisible(False)
self.open_patient_appear_prompt_and_stop_horizontal_box.addWidget(
self.open_patient_window_stop_button)
# Create a widget to hold the layout
self.open_patient_appear_prompt_and_stop_widget = QWidget()
self.open_patient_appear_prompt_and_stop_widget.setLayout(
self.open_patient_appear_prompt_and_stop_horizontal_box)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_appear_prompt_and_stop_widget)
# Create a tree view list to list out all patients in the directory
# selected above
self.open_patient_window_patients_tree = QTreeWidget()
self.open_patient_window_patients_tree.setObjectName(
"OpenPatientWindowPatientsTree")
self.open_patient_window_patients_tree.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_window_patients_tree.resize(
self.open_patient_window_patients_tree.sizeHint().width(),
self.open_patient_window_patients_tree.sizeHint().height())
self.open_patient_window_patients_tree.setHeaderHidden(False)
self.open_patient_window_patients_tree.setHeaderLabels([""])
self.open_patient_window_patients_tree.itemChanged.connect(
self.tree_item_clicked)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_window_patients_tree)
self.last_patient = None
# Create a label to show what would happen if they select the patient
self.open_patient_directory_result_label = QtWidgets.QLabel()
self.open_patient_directory_result_label.setObjectName(
"OpenPatientDirectoryResultLabel")
self.open_patient_directory_result_label.setAlignment(Qt.AlignLeft)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_directory_result_label)
# Create a horizontal box to hold the Cancel and Open button
self.open_patient_window_patient_open_actions_horizontal_box = \
QHBoxLayout()
self.open_patient_window_patient_open_actions_horizontal_box. \
setObjectName("OpenPatientWindowPatientOpenActionsHorizontalBox")
self.open_patient_window_patient_open_actions_horizontal_box. \
addStretch(1)
# Add a button to go back/close from the application
self.open_patient_window_close_button = QPushButton()
self.open_patient_window_close_button.setObjectName(
"OpenPatientWindowcloseButton")
self.open_patient_window_close_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_window_close_button.resize(
self.open_patient_window_stop_button.sizeHint().width(),
self.open_patient_window_stop_button.sizeHint().height())
self.open_patient_window_close_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.open_patient_window_close_button.clicked.connect(
self.close_button_clicked)
self.open_patient_window_close_button.setProperty(
"QPushButtonClass", "fail-button")
self.open_patient_window_patient_open_actions_horizontal_box. \
addWidget(self.open_patient_window_close_button)
# Add a button to confirm opening of the patient
self.open_patient_window_confirm_button = QPushButton()
self.open_patient_window_confirm_button.setObjectName(
"OpenPatientWindowConfirmButton")
self.open_patient_window_confirm_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_window_confirm_button.resize(
self.open_patient_window_confirm_button.sizeHint().width(),
self.open_patient_window_confirm_button.sizeHint().height())
self.open_patient_window_confirm_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.open_patient_window_confirm_button.setDisabled(True)
self.open_patient_window_confirm_button.clicked.connect(
self.confirm_button_clicked)
self.open_patient_window_confirm_button.setProperty(
"QPushButtonClass", "success-button")
self.open_patient_window_patient_open_actions_horizontal_box. \
addWidget(
self.open_patient_window_confirm_button)
# Create a widget to house all of the actions button for open patient
# window
self.open_patient_window_patient_open_actions_widget = QWidget()
self.open_patient_window_patient_open_actions_widget.setLayout(
self.open_patient_window_patient_open_actions_horizontal_box)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_window_patient_open_actions_widget)
# Set the vertical box fourth element, the tree view, to stretch
# out as far as possible
self.open_patient_window_instance_vertical_box.setStretch(3, 4)
self.open_patient_window_instance_central_widget = QWidget()
self.open_patient_window_instance_central_widget.setObjectName(
"OpenPatientWindowInstanceCentralWidget")
self.open_patient_window_instance_central_widget.setLayout(
self.open_patient_window_instance_vertical_box)
# Create threadpool for multithreading
self.threadpool = QThreadPool()
# print("Multithreading with maximum %d threads" % self.threadpool.
# maxThreadCount())
# Create interrupt event for stopping the directory search
self.interrupt_flag = threading.Event()
# Bind all texts into the buttons and labels
self.retranslate_ui(open_image_fusion_select_instance)
# Set the central widget, ready for display
open_image_fusion_select_instance.setCentralWidget(
self.open_patient_window_instance_central_widget)
# Set the current stylesheet to the instance and connect it back
# to the caller through slot
_stylesheet = open(resource_path(self.stylesheet_path)).read()
open_image_fusion_select_instance.setStyleSheet(_stylesheet)
QtCore.QMetaObject.connectSlotsByName(
open_image_fusion_select_instance)
def retranslate_ui(self, open_image_fusion_select_instance):
"""Translates UI"""
_translate = QtCore.QCoreApplication.translate
open_image_fusion_select_instance.setWindowTitle(
_translate("OpenPatientWindowInstance",
"OnkoDICOM - Select Patient"))
self.open_patient_directory_prompt.setText(_translate(
"OpenPatientWindowInstance",
"Choose an image to merge with:"))
self.open_patient_directory_input_box.setPlaceholderText(
_translate("OpenPatientWindowInstance",
"Enter DICOM Files Path (For example, "
"C:\path\\to\your\DICOM\Files)"))
self.open_patient_directory_choose_button.setText(_translate(
"OpenPatientWindowInstance",
"Choose"))
self.open_patient_directory_appear_prompt.setText(_translate(
"OpenPatientWindowInstance",
"Please select below the image set you wish to overlay:"))
self.open_patient_directory_result_label. \
setText("The selected imageset(s) above will be "
"co-registered with the current imageset.")
self.open_patient_window_stop_button.setText(_translate(
"OpenPatientWindowInstance", "Stop Search"))
self.open_patient_window_close_button.setText(_translate(
"OpenPatientWindowInstance", "Close"))
self.open_patient_window_confirm_button.setText(_translate(
"OpenPatientWindowInstance", "Confirm"))
def update_patient(self):
self.clear_checked_leaves()
self.patient_dict_container = PatientDictContainer()
self.patient = self.patient_dict_container.get("basic_info")
self.patient_id = self.patient['id']
dataset = self.patient_dict_container.dataset[0]
self.patient_current_image_series_uid = \
dataset.get("SeriesInstanceUID")
def clear_checked_leaves(self):
"""
Resets all leaves to their unchecked state
"""
def recurse(parent_item: QTreeWidgetItem):
for i in range(parent_item.childCount()):
child = parent_item.child(i)
grand_children = child.childCount()
if grand_children > 0:
recurse(child)
else:
if child.checkState(0) == Qt.Checked:
child.setCheckState(0, Qt.CheckState.Unchecked)
child.setSelected(False)
recurse(self.open_patient_window_patients_tree.invisibleRootItem())
self.open_patient_window_patients_tree.collapseAll()
def close_button_clicked(self):
"""Closes the window."""
self.close()
def scan_directory_for_patient(self):
# Reset tree view header and last patient
self.open_patient_window_confirm_button.setDisabled(True)
self.open_patient_window_patients_tree.setHeaderLabels([""])
self.last_patient = None
self.filepath = self.open_patient_directory_input_box.text()
# Proceed if a folder was selected
if self.filepath != "":
# Update the QTreeWidget to reflect data being loaded
# First, clear the widget of any existing data
self.open_patient_window_patients_tree.clear()
# Next, update the tree widget
self.open_patient_window_patients_tree.addTopLevelItem(
QTreeWidgetItem(["Loading selected directory..."]))
# The choose button is disabled until the thread finishes executing
self.open_patient_directory_choose_button.setEnabled(False)
# Reveals the Stop Search button for the duration of the search
self.open_patient_window_stop_button.setVisible(True)
# The interrupt flag is then un-set if a previous search has been
# stopped.
self.interrupt_flag.clear()
# Then, create a new thread that will load the selected folder
worker = Worker(DICOMDirectorySearch.get_dicom_structure,
self.filepath,
self.interrupt_flag, progress_callback=True)
worker.signals.result.connect(self.on_search_complete)
worker.signals.progress.connect(self.search_progress)
# Execute the thread
self.threadpool.start(worker)
def choose_button_clicked(self):
"""
Executes when the choose button is clicked.
Gets filepath from the user and loads all files and subdirectories.
"""
# Get folder path from pop up dialog box
self.filepath = QtWidgets.QFileDialog.getExistingDirectory(
None, 'Select patient folder...', '')
self.open_patient_directory_input_box.setText(self.filepath)
self.scan_directory_for_patient()
def stop_button_clicked(self):
self.interrupt_flag.set()
def search_progress(self, progress_update):
"""
Current progress of the file search.
"""
self.open_patient_window_patients_tree.clear()
self.open_patient_window_patients_tree.addTopLevelItem(
QTreeWidgetItem(["Loading selected directory... "
"(%s files searched)" % progress_update]))
def on_search_complete(self, dicom_structure):
"""
Executes once the directory search is complete.
:param dicom_structure: DICOMStructure object constructed by the
directory search.
"""
self.open_patient_directory_choose_button.setEnabled(True)
self.open_patient_window_stop_button.setVisible(False)
self.open_patient_window_patients_tree.clear()
# dicom_structure will be None if function was interrupted.
if dicom_structure is None:
return
for patient_item in dicom_structure.get_tree_items_list():
self.open_patient_window_patients_tree.addTopLevelItem(
patient_item)
patient_item.setExpanded(True) # Display all studies
# Display all image sets
for i in range(patient_item.childCount()):
study = patient_item.child(i)
study.setExpanded(True)
if len(dicom_structure.patients) == 0:
QMessageBox.about(self, "No files found",
"Selected directory contains no DICOM files.")
def tree_item_clicked(self, item, _):
"""
Executes when a tree item is checked or unchecked.
If a different patient is checked, uncheck the previous patient.
Inform user about missing DICOM files.
"""
# If patient is only selected, but not checked, set it to "focus" to
# coincide with stylesheet. And if the selected item is an image set,
# display its child branches.
if item.checkState(0) == Qt.CheckState.Unchecked:
self.open_patient_window_patients_tree.setCurrentItem(item)
else: # Otherwise don't "focus", then set patient as selected
self.open_patient_window_patients_tree.setCurrentItem(None)
item.setSelected(True)
# Expand or collapse the tree branch if item is an image series
# Only collapse if the selected image series is expanded but unchecked
# Otherwise, expand its tree branch to show RT files
is_expanded = False \
if (item.isExpanded() is True and
item.checkState(0) == Qt.CheckState.Unchecked) else True
self.display_a_tree_branch(item, is_expanded)
selected_patient = item
# If the item is not top-level, bubble up to see which top-level item
# this item belongs to
if self.open_patient_window_patients_tree.invisibleRootItem(). \
indexOfChild(item) == -1:
while self.open_patient_window_patients_tree.invisibleRootItem(). \
indexOfChild(selected_patient) == -1:
selected_patient = selected_patient.parent()
# Uncheck previous patient if a different patient is selected
if item.checkState(0) == Qt.CheckState.Checked and self.last_patient \
!= selected_patient:
if self.last_patient is not None:
last_patient_checked_items = self.get_checked_nodes(
self.last_patient)
for checked_item in last_patient_checked_items:
checked_item.setCheckState(0, Qt.Unchecked)
self.last_patient = selected_patient
# Check selected items and display warning messages
self.check_selected_items(selected_patient)
def display_a_tree_branch(self, node, is_expanded):
# TO DO:
# Could Team 23 please update the defintion of this docstring as
# well as same function presented in OpenPatientWindow.
"""
Displays a tree branch
Parameters:
node : root node the tree
is_expanded (boolean): flag for checking if a particular
node/leaf is expanded.
"""
node.setExpanded(is_expanded)
if node.childCount() > 0:
for i in range(node.childCount()):
self.display_a_tree_branch(node.child(i), is_expanded)
else:
return
def check_selected_items(self, selected_patient):
"""
Check and display warning messages based on the existence and quantity
of image series, RTSTRUCT, RTPLAN, RTDOSE and SR files
Parameters:
selected_patient (DICOMStructure): DICOM Object of patient
"""
# Get the types of all selected leaves & Get the names of all selected
# studies
checked_nodes = self.get_checked_nodes(
self.open_patient_window_patients_tree.invisibleRootItem())
selected_series_types = [checked_node.dicom_object.get_series_type()
for checked_node in checked_nodes]
selected_series_id = [checked_node.dicom_object.series_uid
for checked_node in checked_nodes]
# Total number of selected image series
total_selected_image_series = selected_series_types.count('CT') + \
selected_series_types.count('MR') + \
selected_series_types.count('PT')
# Check the existence of IMAGE, RTSTRUCT, RTPLAN and RTDOSE files
proceed = True
if total_selected_image_series < 1:
header = "Cannot proceed without an image."
proceed = False
elif total_selected_image_series > 1:
header = "Cannot proceed with more than 1 selected image."
proceed = False
elif selected_patient.dicom_object.patient_id.strip() != \
self.patient_id:
header = "Cannot proceed with different patient."
proceed = False
elif self.patient_current_image_series_uid in selected_series_id:
header = "Cannot fuse with the same series."
proceed = False
elif not self.check_selected_items_referencing(checked_nodes):
# Check that selected items properly reference each other
header = "Selected series do not reference each other."
proceed = False
elif 'RTSTRUCT' not in selected_series_types and \
self.check_existing_rtss(checked_nodes):
header = "The associated RTSTRUCT must be selected."
proceed = False
elif 'RTDOSE' in selected_series_types:
header = "Cannot fuse with a RTDOSE file."
proceed = False
else:
header = ""
self.open_patient_window_confirm_button.setDisabled(not proceed)
# Set the tree header
self.open_patient_window_patients_tree.setHeaderLabel(header)
def check_selected_items_referencing(self, items):
"""
Check if selected tree items properly reference each other.
:param items: List of selected DICOMWidgetItems.
:return: True if the selected items belong to the same tree branch.
"""
# Dictionary of series of different file types
series = {
"IMAGE": None,
"RTSTRUCT": None,
"RTPLAN": None,
"RTDOSE": None,
"SR": None
}
for item in items:
series_type = item.dicom_object.get_series_type()
if series_type in series:
series[series_type] = item
else:
series["IMAGE"] = item
# Check if the RTSTRUCT, RTPLAN, and RTDOSE are a child item of the
# image series
if series["IMAGE"]:
if series["RTSTRUCT"] and series["RTSTRUCT"].parent() != \
series["IMAGE"]:
return False
if series["RTPLAN"] and \
series["RTPLAN"].parent().parent() != series["IMAGE"]:
return False
if series["SR"] and series["SR"].parent() != series["IMAGE"]:
return False
return True
def check_existing_rtss(self, items):
"""
Check for existing rtss
:return: bool, whether there is a rtss associated with the selected
image series
"""
image_series = ['CT', 'MR', 'PT']
for item in items:
if item.dicom_object.get_series_type() in image_series:
for i in range(item.childCount()):
if item.child(i).dicom_object:
return True
return False
def get_checked_nodes(self, root):
"""
:param root: QTreeWidgetItem as a root.
:return: A list of all QTreeWidgetItems in the QTreeWidget that are
checked under the root.
"""
checked_items = []
def recurse(parent_item: QTreeWidgetItem):
for i in range(parent_item.childCount()):
child = parent_item.child(i)
if int(child.flags()) & int(Qt.ItemIsUserCheckable) and \
child.checkState(0) == Qt.Checked:
checked_items.append(child)
grand_children = child.childCount()
if grand_children > 0:
recurse(child)
recurse(root)
return checked_items
def confirm_button_clicked(self):
"""
Begins loading of the selected files.
"""
selected_files = []
for item in self.get_checked_nodes(
self.open_patient_window_patients_tree.invisibleRootItem()):
selected_files += item.dicom_object.get_files()
self.progress_window = ImageFusionProgressWindow(self)
self.progress_window.signal_loaded.connect(self.on_loaded)
self.progress_window.signal_error.connect(self.on_loading_error)
self.progress_window.start_loading(selected_files)
def on_loaded(self, results):
"""
Executes when the progress bar finishes loaded the selected files.
"""
if results[0] is True: # Will be NoneType if loading was interrupted.
self.image_fusion_info_initialized.emit(results[1])
def on_loading_error(self, exception):
"""
Error handling for progress window.
"""
if type(exception[1]) == ImageLoading.NotRTSetError:
QMessageBox.about(self.progress_window,
"Unable to open selection",
"Selected files cannot be opened as they are not"
" a DICOM-RT set.")
self.progress_window.close()
elif type(exception[1]) == ImageLoading.NotAllowedClassError:
QMessageBox.about(self.progress_window,
"Unable to open selection",
"Selected files cannot be opened as they contain"
" unsupported DICOM classes.")
self.progress_window.close()
class UITransferROIWindow:
def setup_ui(self, transfer_roi_window_instance,
signal_roi_transferred_to_fixed_container,
signal_roi_transferred_to_moving_container):
self.patient_dict_container = PatientDictContainer()
self.moving_dict_container = MovingDictContainer()
self.fixed_image_initial_rois = self.patient_dict_container.get("rois")
self.moving_image_initial_rois = self.moving_dict_container.get("rois")
self.transfer_roi_window_instance = transfer_roi_window_instance
self.signal_roi_transferred_to_fixed_container = \
signal_roi_transferred_to_fixed_container
self.signal_roi_transferred_to_moving_container = \
signal_roi_transferred_to_moving_container
self.fixed_to_moving_rois = {}
self.moving_to_fixed_rois = {}
self.add_suffix = True
self.progress_window = ProgressWindow(
self, QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowCloseButtonHint)
self.progress_window.setFixedSize(250, 100)
self.progress_window.signal_loaded \
.connect(self.onTransferRoiFinished)
self.progress_window.signal_error.connect(self.onTransferRoiError)
self.init_layout()
def retranslate_ui(self, transfer_roi_window_instance):
_translate = QtCore.QCoreApplication.translate
transfer_roi_window_instance.setWindowTitle(
_translate("TransferRoiWindowInstance",
"OnkoDICOM - Transfer Region of Interest"))
self.add_suffix_checkbox.setText(
_translate("AddSuffixCheckBox", "Add Suffix"))
self.patient_A_label.setText(
_translate("PatientAROILabel", "First Image Set ROIs"))
self.patient_B_label.setText(
_translate("PatientBROILabel", "Second Image Set ROIs"))
self.transfer_all_rois_to_patient_B_button.setText(
_translate("ROITransferToBButton", "All"))
self.transfer_all_rois_to_patient_A_button.setText(
_translate("ROITransferToAButton", "All"))
self.save_button.setText(_translate("SaveButton", "Save"))
self.reset_button.setText(_translate("ResetButton", "Reset"))
def init_layout(self):
"""
Initialize the layout for the Transfer ROI Window.
"""
if platform.system() == 'Darwin':
self.stylesheet_path = "res/stylesheet.qss"
else:
self.stylesheet_path = "res/stylesheet-win-linux.qss"
stylesheet = open(resource_path(self.stylesheet_path)).read()
window_icon = QIcon()
window_icon.addPixmap(QPixmap(resource_path("res/images/icon.ico")),
QIcon.Normal, QIcon.Off)
self.transfer_roi_window_instance.setObjectName(
"TransferRoiWindowInstance")
self.transfer_roi_window_instance.setWindowIcon(window_icon)
# Creating a grid layout to hold all elements
self.transfer_roi_window_grid_layout = QGridLayout()
self.transfer_roi_window_grid_layout.setColumnStretch(0, 1)
self.transfer_roi_window_grid_layout.setColumnStretch(1, 1)
self.transfer_roi_window_grid_layout.setColumnStretch(2, 1)
self.init_patient_labels()
self.init_transfer_arrow_buttons()
self.init_patient_A_initial_roi_list()
self.init_patient_B_rois_to_A_layout()
self.init_patient_A_rois_to_B_layout()
self.init_patient_B_initial_roi_list()
self.init_add_suffix_checkbox()
self.init_save_and_reset_button_layout()
# Create a new central widget to hold the grid layout
self.transfer_roi_window_instance_central_widget = QWidget()
self.transfer_roi_window_instance_central_widget.setLayout(
self.transfer_roi_window_grid_layout)
self.retranslate_ui(self.transfer_roi_window_instance)
self.transfer_roi_window_instance.setStyleSheet(stylesheet)
self.transfer_roi_window_instance.setCentralWidget(
self.transfer_roi_window_instance_central_widget)
QtCore.QMetaObject.connectSlotsByName(
self.transfer_roi_window_instance)
def init_transfer_arrow_buttons(self):
"""
Initialize the layout for arrow buttons
"""
self.transfer_all_rois_to_patient_B_button = QPushButton()
self.transfer_all_rois_to_patient_B_button.setObjectName(
"ROITransferToBButton")
transfer_all_rois_to_patient_B_icon = QtGui.QIcon()
transfer_all_rois_to_patient_B_icon.addPixmap(
QtGui.QPixmap(
resource_path('res/images/btn-icons/forward_slide_icon.png')),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.transfer_all_rois_to_patient_B_button \
.setIcon(transfer_all_rois_to_patient_B_icon)
self.transfer_all_rois_to_patient_B_button.clicked.connect(
self.transfer_all_rois_to_patient_B_button_clicked)
self.transfer_roi_window_grid_layout.addWidget(
self.transfer_all_rois_to_patient_B_button, 1, 1)
self.transfer_all_rois_to_patient_A_button = QPushButton()
self.transfer_all_rois_to_patient_A_button.setObjectName(
"ROITransferToAButton")
self.transfer_all_rois_to_patient_A_button.setMaximumWidth(100)
transfer_all_rois_to_patient_A_icon = QtGui.QIcon()
transfer_all_rois_to_patient_A_icon.addPixmap(
QtGui.QPixmap(
resource_path('res/images/btn-icons/backward_slide_icon.png')),
QtGui.QIcon.Normal, QtGui.QIcon.On)
self.transfer_all_rois_to_patient_A_button \
.setIcon(transfer_all_rois_to_patient_A_icon)
self.transfer_all_rois_to_patient_A_button.clicked.connect(
self.transfer_all_rois_to_patient_A_button_clicked)
self.transfer_roi_window_grid_layout.addWidget(
self.transfer_all_rois_to_patient_A_button, 2, 1)
def transfer_all_rois_to_patient_B_button_clicked(self):
"""
This function is triggered when the right arrow button is clicked.
"""
self.fixed_to_moving_rois.clear()
self.patient_A_rois_to_B_list_widget.clear()
for i in range(0, len(self.fixed_image_initial_rois)):
self.patient_A_initial_roi_double_clicked(
self.patient_A_initial_rois_list_widget.item(i))
def transfer_all_rois_to_patient_A_button_clicked(self):
"""
This function is triggered when the left arrow button is clicked.
"""
self.moving_to_fixed_rois.clear()
self.patient_B_rois_to_A_list_widget.clear()
for i in range(0, len(self.moving_image_initial_rois)):
self.patient_B_initial_roi_double_clicked(
self.patient_B_initial_rois_list_widget.item(i))
def init_add_suffix_checkbox(self):
"""
Initialize the layout for add suffix checkbox
"""
self.add_suffix_checkbox = QCheckBox()
self.add_suffix_checkbox.setObjectName("AddSuffixCheckBox")
self.add_suffix_checkbox.setChecked(self.add_suffix)
self.add_suffix_checkbox.clicked.connect(
self.add_suffix_checkbox_clicked)
self.transfer_roi_window_grid_layout.addWidget(
self.add_suffix_checkbox, 3, 0)
def init_patient_labels(self):
"""
Initialize the layout for two patient labels
"""
self.patient_A_label = QLabel()
self.patient_A_label.setObjectName("PatientAROILabel")
self.patient_A_label.setMinimumHeight(50)
self.patient_A_label.setAlignment(Qt.AlignCenter)
self.patient_A_label.setStyleSheet(
"QLabel { background-color : green; color : white; "
"font-size: 15pt; font-weight: bold;}")
self.patient_B_label = QLabel()
self.patient_B_label.setObjectName("PatientBROILabel")
self.patient_B_label.setMinimumHeight(50)
self.patient_B_label.setAlignment(Qt.AlignCenter)
self.patient_B_label.setStyleSheet(
"QLabel { background-color : red; color : white; "
"font-size: 15pt; font-weight: bold;}")
self.transfer_roi_window_grid_layout.addWidget(self.patient_A_label, 0,
0)
self.transfer_roi_window_grid_layout.addWidget(self.patient_B_label, 0,
2)
def init_save_and_reset_button_layout(self):
"""
Initialize the layout for save and reset buttons
"""
self.reset_and_save_buttons_layout = QHBoxLayout()
self.reset_button = QPushButton()
self.reset_button.setObjectName("ResetButton")
self.reset_button.clicked.connect(self.reset_clicked)
self.save_button = QPushButton()
self.save_button.setObjectName("SaveButton")
self.save_button.setDisabled(True)
self.save_button.clicked.connect(self.transfer_roi_clicked)
self.reset_and_save_buttons_layout.setAlignment(Qt.AlignRight)
self.reset_and_save_buttons_layout.addWidget(self.reset_button)
self.reset_and_save_buttons_layout.addWidget(self.save_button)
# Create a widget to hold Reset and Save buttons
self.reset_and_save_button_central_widget = QWidget()
self.reset_and_save_button_central_widget.setLayout(
self.reset_and_save_buttons_layout)
self.transfer_roi_window_grid_layout.addWidget(
self.reset_and_save_button_central_widget, 3, 2)
def add_suffix_checkbox_clicked(self):
"""
This function is triggered when the add suffix checkbox is clicked
"""
self.add_suffix = self.add_suffix_checkbox.isChecked()
def init_patient_B_rois_to_A_layout(self):
"""
Initialize the layout for transfer rois from B to A container
"""
# Create scrolling area widget to contain the content.
self.patient_B_rois_to_A_list_widget = QListWidget(self)
self.transfer_roi_window_grid_layout \
.addWidget(self.patient_B_rois_to_A_list_widget, 2, 0)
self.patient_B_rois_to_A_list_widget.itemDoubleClicked.connect(
self.patient_B_to_A_rois_double_clicked)
def init_patient_A_rois_to_B_layout(self):
"""
Initialize the layout for transfer rois from A to B container
"""
self.patient_A_rois_to_B_list_widget = QListWidget(self)
self.transfer_roi_window_grid_layout \
.addWidget(self.patient_A_rois_to_B_list_widget, 1, 2)
self.patient_A_rois_to_B_list_widget.itemDoubleClicked.connect(
self.patient_A_to_B_rois_double_clicked)
def init_patient_A_initial_roi_list(self):
"""
Initialize the layout for patient A's roi list
"""
self.patient_A_initial_rois_list_widget = QListWidget(self)
self.patient_A_initial_rois_list_widget.itemDoubleClicked.connect(
self.patient_A_initial_roi_double_clicked)
for idx in self.fixed_image_initial_rois:
roi_label = QListWidgetItem(
self.fixed_image_initial_rois[idx]['name'])
roi_label.setForeground(Qt.darkGreen)
roi_label.setData(Qt.UserRole, self.fixed_image_initial_rois[idx])
self.patient_A_initial_rois_list_widget.addItem(roi_label)
self.transfer_roi_window_grid_layout.addWidget(
self.patient_A_initial_rois_list_widget, 1, 0)
def init_patient_B_initial_roi_list(self):
"""
Initialize the layout for patient B's roi list
"""
self.patient_B_initial_rois_list_widget = QListWidget(self)
self.patient_B_initial_rois_list_widget.itemDoubleClicked.connect(
self.patient_B_initial_roi_double_clicked)
for idx in self.moving_image_initial_rois:
roi_label = QListWidgetItem(
self.moving_image_initial_rois[idx]['name'])
roi_label.setForeground(Qt.red)
roi_label.setData(Qt.UserRole, self.moving_image_initial_rois[idx])
self.patient_B_initial_rois_list_widget.addItem(roi_label)
self.transfer_roi_window_grid_layout.addWidget(
self.patient_B_initial_rois_list_widget, 2, 2)
def patient_A_to_B_rois_double_clicked(self, item):
"""
This function is triggered when a roi in "A to B" list is
double-clicked.
"""
roi_to_remove = item.data(Qt.UserRole)
to_delete_value = roi_to_remove['name']
self.fixed_to_moving_rois.pop(to_delete_value)
self.patient_A_rois_to_B_list_widget.clear()
for key, value in self.fixed_to_moving_rois.items():
roi_label = QListWidgetItem(value)
roi_label.setForeground(Qt.red)
roi_label.setData(Qt.UserRole, {'name': key})
self.patient_A_rois_to_B_list_widget.addItem(roi_label)
if self.transfer_list_is_empty():
self.save_button.setDisabled(True)
def patient_B_to_A_rois_double_clicked(self, item):
"""
This function is triggered when a roi in "B to A" list is
double-clicked.
"""
roi_to_remove = item.data(Qt.UserRole)
to_delete_value = roi_to_remove['name']
self.moving_to_fixed_rois.pop(to_delete_value)
self.patient_B_rois_to_A_list_widget.clear()
for key, value in self.moving_to_fixed_rois.items():
roi_label = QListWidgetItem(value)
roi_label.setForeground(Qt.red)
roi_label.setData(Qt.UserRole, {'name': key})
self.patient_B_rois_to_A_list_widget.addItem(roi_label)
if self.transfer_list_is_empty():
self.save_button.setDisabled(True)
def patient_A_initial_roi_double_clicked(self, item):
"""
This function is triggered when a roi in patient A's roi list is
double-clicked.
"""
roi_to_add = item.data(Qt.UserRole)
transferred_roi_name = roi_to_add['name']
# If the clicked roi is already transferred, return
if transferred_roi_name in self.fixed_to_moving_rois.keys():
QMessageBox.about(self, "Transfer Failed",
"Chosen ROI has already been transferred!")
return
# Create a set to store all current roi names in target patient
# including both initial rois name and added roi names so far
patient_B_initial_roi_name_list = set()
for item in self.fixed_to_moving_rois.values():
patient_B_initial_roi_name_list.add(item)
for idx in self.moving_image_initial_rois:
patient_B_initial_roi_name_list.add(
self.moving_image_initial_rois[idx]['name'])
# Check if clicked roi name has duplicate
# in patient B's initial roi names list
if transferred_roi_name in patient_B_initial_roi_name_list:
if self.add_suffix:
transferred_roi_name = generate_non_duplicated_name(
transferred_roi_name, patient_B_initial_roi_name_list)
else:
QMessageBox.about(
self, "Transfer Failed", "Duplicated ROI name. "
"Please consider adding suffix.")
return
# Add clicked roi to transferred list
self.fixed_to_moving_rois[roi_to_add['name']] = transferred_roi_name
roi_label = QListWidgetItem(transferred_roi_name)
roi_label.setForeground(Qt.red)
roi_label.setData(Qt.UserRole, roi_to_add)
self.patient_A_rois_to_B_list_widget.addItem(roi_label)
self.save_button.setDisabled(False)
def patient_B_initial_roi_double_clicked(self, item):
"""
This function is triggered when a roi in patient B's roi list is
double-clicked.
"""
roi_to_add = item.data(Qt.UserRole)
transferred_roi_name = roi_to_add['name']
# If the clicked roi is already transferred, return
if transferred_roi_name in self.moving_to_fixed_rois.keys():
QMessageBox.about(self, "Transfer Failed",
"Chosen ROI has already been transferred!")
return
# Create a set to store all current roi names in target patient
# including both initial rois name and added roi names so far
patient_A_current_roi_name_list = set()
for item in self.moving_to_fixed_rois.values():
patient_A_current_roi_name_list.add(item)
for idx in self.fixed_image_initial_rois:
patient_A_current_roi_name_list.add(
self.fixed_image_initial_rois[idx]['name'])
# Check if clicked roi name has duplicate in
# target patient's roi names list
if transferred_roi_name in patient_A_current_roi_name_list:
# if add suffix is ticked, iteratively try adding suffix
# from _A to _Z, stop when no duplicate found
if self.add_suffix:
transferred_roi_name = generate_non_duplicated_name(
transferred_roi_name, patient_A_current_roi_name_list)
else:
QMessageBox.about(
self, "Transfer Failed", "Duplicated ROI name. "
"Please consider adding suffix.")
return
# Add clicked roi to transferred list
self.moving_to_fixed_rois[roi_to_add['name']] = transferred_roi_name
roi_label = QListWidgetItem(transferred_roi_name)
roi_label.setForeground(Qt.red)
roi_label.setData(Qt.UserRole, roi_to_add)
self.patient_B_rois_to_A_list_widget.addItem(roi_label)
self.save_button.setDisabled(False)
def reset_clicked(self):
"""
This function is triggered when reset button is clicked.
"""
self.fixed_to_moving_rois.clear()
self.moving_to_fixed_rois.clear()
self.patient_A_rois_to_B_list_widget.clear()
self.patient_B_rois_to_A_list_widget.clear()
self.save_button.setDisabled(True)
def transfer_list_is_empty(self):
"""
This function is to check if the transfer list is empty
"""
return len(self.fixed_to_moving_rois) == 0 \
and len(self.moving_to_fixed_rois) == 0
def save_clicked(self, interrupt_flag, progress_callback):
"""
This function is triggered when the save button is clicked. It contains
all steps in the ROI transferring process.
:param interrupt_flag: interrupt flag to stop process
:param progress_callback: signal that receives the current
progress of the loading.
"""
progress_callback.emit(("Converting images to sitk", 0))
# check if interrupt flag is set
if not check_interrupt_flag(interrupt_flag):
return False
rtss = self.patient_dict_container.get("dataset_rtss")
# get sitk for the fixed image
dicom_image = read_dicom_image_to_sitk(
self.patient_dict_container.filepaths)
if not check_interrupt_flag(interrupt_flag):
return False
# get array of roi indexes from sitk images
rois_images_fixed = transform_point_set_from_dicom_struct(
dicom_image,
rtss,
self.fixed_to_moving_rois.keys(),
spacing_override=None,
interrupt_flag=interrupt_flag)
moving_rtss = self.moving_dict_container.get("dataset_rtss")
if not check_interrupt_flag(interrupt_flag):
return False
# get sitk for the moving image
moving_dicom_image = read_dicom_image_to_sitk(
self.moving_dict_container.filepaths)
if not check_interrupt_flag(interrupt_flag):
return False
# get array of roi indexes from sitk images
progress_callback \
.emit(("Retrieving ROIs from \nboth image sets", 20))
# check if interrupt flag is set
if not check_interrupt_flag(interrupt_flag):
return False
if moving_rtss:
rois_images_moving = transform_point_set_from_dicom_struct(
moving_dicom_image,
moving_rtss,
self.moving_to_fixed_rois.keys(),
spacing_override=None,
interrupt_flag=interrupt_flag)
else:
rois_images_moving = ([], [])
if not check_interrupt_flag(interrupt_flag):
return False
tfm = self.moving_dict_container.get("tfm")
progress_callback.emit(
("Transfering ROIs from moving \nto fixed image set", 40))
# check if interrupt flag is set
if not check_interrupt_flag(interrupt_flag):
return False
# transform roi from moving_dict to fixed_dict
self.transfer_rois(self.moving_to_fixed_rois, tfm, dicom_image,
rois_images_moving, self.patient_dict_container)
progress_callback.emit(
("Transfering ROIs from fixed \nto moving image set", 60))
if not check_interrupt_flag(interrupt_flag):
return False
# transform roi from moving_dict to fixed_dict
self.transfer_rois(self.fixed_to_moving_rois, tfm.GetInverse(),
moving_dicom_image, rois_images_fixed,
self.moving_dict_container)
progress_callback.emit(("Saving ROIs to RTSS", 80))
# check if interrupt flag is set
if not check_interrupt_flag(interrupt_flag):
return False
progress_callback.emit(("Reloading window", 90))
return True
def transfer_roi_clicked(self):
"""
telling progress window to start ROI transfer
"""
self.progress_window.start(self.save_clicked)
def onTransferRoiError(self, exception):
"""
This function is triggered when there is an error in the
ROI transferring process.
:param exception: exception thrown
"""
QMessageBox.about(self.progress_window, "Unable to transfer ROIs",
"Please check your image set and ROI data.")
self.progress_window.close()
def onTransferRoiFinished(self, result):
"""
This function is triggered when ROI transferring process is finished.
"""
# emit changed dataset to structure_modified function and
# auto_save_roi function
if result[0] is True:
if len(self.fixed_to_moving_rois) > 0:
self.signal_roi_transferred_to_moving_container.emit(
(self.moving_dict_container.get("dataset_rtss"), {
"transfer": None
}))
if len(self.moving_to_fixed_rois) > 0:
self.signal_roi_transferred_to_fixed_container.emit(
(self.patient_dict_container.get("dataset_rtss"), {
"transfer": None
}))
self.progress_window.close()
QMessageBox.about(self.transfer_roi_window_instance, "Saved",
"ROIs are successfully transferred!")
else:
QMessageBox.about(self.transfer_roi_window_instance, "Cancelled",
"ROIs Transfer is cancelled.")
self.closeWindow()
def transfer_rois(self, transfer_dict, tfm, reference_image,
original_roi_list, patient_dict_container):
"""
Converting (transferring) ROIs from one image set to another and save
the transferred rois to rtss.
:param transfer_dict: dictionary of rois to be transfer.
key is original roi names, value is the name after transferred.
:param original_roi_list: tuple of sitk rois from the base image.
:param tfm: the tfm that contains information for transferring rois
:param reference_image: the reference (base) image
:param patient_dict_container: container of the transfer image set.
"""
for roi_name, new_roi_name in transfer_dict.items():
for index, name in enumerate(original_roi_list[1]):
if name == roi_name:
sitk_image = original_roi_list[0][index]
new_contour = apply_linear_transform(
input_image=sitk_image,
transform=tfm,
reference_image=reference_image,
is_structure=True)
contour = sitk.GetArrayViewFromImage(new_contour)
contours = np.transpose(contour.nonzero())
self.save_roi_to_patient_dict_container(
contours, new_roi_name, patient_dict_container)
def save_roi_to_patient_dict_container(self, contours, roi_name,
patient_dict_container):
"""
Save the transferred ROI to the corresponding rtss.
:param contours: np array of coordinates of the ROI to be saved.
:param roi_name: name of the ROI to be saved
:param patient_dict_container: container of the transfer image set.
"""
pixels_coords_dict = {}
slice_ids_dict = get_dict_slice_to_uid(patient_dict_container)
total_slices = len(slice_ids_dict)
for contour in contours:
curr_slice_id = total_slices - contour[0]
if curr_slice_id >= total_slices:
curr_slice_id = 0
if curr_slice_id not in pixels_coords_dict:
pixels_coords_dict[curr_slice_id] = [
tuple([contour[2], contour[1]])
]
else:
pixels_coords_dict[curr_slice_id].append(
tuple([contour[2], contour[1]]))
rois_to_save = {}
for key in pixels_coords_dict.keys():
coords = pixels_coords_dict[key]
polygon_list = ROI.calculate_concave_hull_of_points(coords)
if len(polygon_list) > 0:
rois_to_save[key] = {
'ds': patient_dict_container.dataset[key],
'coords': polygon_list
}
roi_list = ROI.convert_hull_list_to_contours_data(
rois_to_save, patient_dict_container)
if len(roi_list) > 0:
print("Saving ", roi_name)
if isinstance(patient_dict_container, MovingDictContainer):
new_rtss = ROI.create_roi(
patient_dict_container.get("dataset_rtss"),
roi_name,
roi_list,
rtss_owner="MOVING")
self.moving_dict_container.set("dataset_rtss", new_rtss)
self.moving_dict_container.set("rtss_modified", True)
else:
new_rtss = ROI.create_roi(
patient_dict_container.get("dataset_rtss"), roi_name,
roi_list)
self.patient_dict_container.set("dataset_rtss", new_rtss)
self.patient_dict_container.set("rtss_modified", True)
def closeWindow(self):
"""
function to close transfer roi window
"""
self.close()
class BatchProcessISO2ROI(BatchProcess):
"""
This class handles batch processing for the ISO2ROI process.
Inherits from the BatchProcess class.
"""
# Allowed classes for ISO2ROI
allowed_classes = {
# CT Image
"1.2.840.10008.5.1.4.1.1.2": {
"name": "ct",
"sliceable": True
},
# RT Structure Set
"1.2.840.10008.5.1.4.1.1.481.3": {
"name": "rtss",
"sliceable": False
},
# RT Dose
"1.2.840.10008.5.1.4.1.1.481.2": {
"name": "rtdose",
"sliceable": False
},
# RT Plan
"1.2.840.10008.5.1.4.1.1.481.5": {
"name": "rtplan",
"sliceable": False
}
}
def __init__(self, progress_callback, interrupt_flag, patient_files):
"""
Class initialiser function.
:param progress_callback: A signal that receives the current
progress of the loading.
:param interrupt_flag: A threading.Event() object that tells the
function to stop loading.
:param patient_files: List of patient files.
"""
# Call the parent class
super(BatchProcessISO2ROI, self).__init__(progress_callback,
interrupt_flag,
patient_files)
# Set class variables
self.patient_dict_container = PatientDictContainer()
self.required_classes = ('ct', 'rtdose', 'rtplan')
self.ready = self.load_images(patient_files, self.required_classes)
def start(self):
"""
Goes through the steps of the ISO2ROI conversion.
:return: True if successful, False if not.
"""
# Stop loading
if self.interrupt_flag.is_set():
# TODO: convert print to logging
print("Stopped ISO2ROI")
self.patient_dict_container.clear()
self.summary = "INTERRUPT"
return False
if not self.ready:
self.summary = "SKIP"
return False
# Update progress
self.progress_callback.emit(("Setting up...", 30))
# Initialise
InitialModel.create_initial_model_batch()
# Stop loading
if self.interrupt_flag.is_set():
# TODO: convert print to logging
print("Stopped ISO2ROI")
self.patient_dict_container.clear()
self.summary = "INTERRUPT"
return False
# Check if the dataset is complete
self.progress_callback.emit(("Checking dataset...", 40))
dataset_complete = ImageLoading.is_dataset_dicom_rt(
self.patient_dict_container.dataset)
# Create ISO2ROI object
iso2roi = ISO2ROI()
self.progress_callback.emit(("Performing ISO2ROI... ", 50))
# Stop loading
if self.interrupt_flag.is_set():
# TODO: convert print to logging
print("Stopped ISO2ROI")
self.patient_dict_container.clear()
self.summary = "INTERRUPT"
return False
if not dataset_complete:
# Check if RT struct file is missing. If yes, create one and
# add its data to the patient dict container. Otherwise
# return
if not self.patient_dict_container.get("file_rtss"):
self.progress_callback.emit(("Generating RT Struct", 55))
self.create_new_rtstruct(self.progress_callback)
# Get isodose levels to turn into ROIs
isodose_levels = \
iso2roi.get_iso_levels(data_path('batch_isodoseRoi.csv'))
# Stop loading
if self.interrupt_flag.is_set():
# TODO: convert print to logging
print("Stopped ISO2ROI")
self.patient_dict_container.clear()
self.summary = "INTERRUPT"
return False
# Calculate boundaries
self.progress_callback.emit(("Calculating boundaries...", 60))
boundaries = iso2roi.calculate_isodose_boundaries(isodose_levels)
# Return if boundaries could not be calculated
if not boundaries:
print("Boundaries could not be calculated.")
self.summary = "ISO_NO_RX_DOSE"
return False
# Generate ROIs
self.progress_callback.emit(("Generating ROIs...", 80))
iso2roi.generate_roi(boundaries, self.progress_callback)
# Save new RTSS
self.progress_callback.emit(("Saving RT Struct...", 90))
self.save_rtss()
return True
