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.
"""
# Get the values for window and level from the dict
windowing_limits = self.patient_dict_container.get(
"dict_windowing")[text]
# Set window and level to the new values
window = windowing_limits[0]
level = windowing_limits[1]
# Update the dictionary of pixmaps with the update window and level values
pixel_values = self.patient_dict_container.get("pixel_values")
pixmaps = get_pixmaps(pixel_values, window, level)
self.patient_dict_container.set("window", window)
self.patient_dict_container.set("level", level)
self.patient_dict_container.set("pixmaps", pixmaps)
self.__main_page.update_views()
def create_pt_ct_model():
"""
This function initializes all the attributes in the
MovingDictContainer 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 MovingDictContainer instance are set (i.e. dataset
and filepaths).
"""
##############################
# LOAD PATIENT INFORMATION #
##############################
pt_ct_dict_container = PTCTDictContainer()
pt_dataset = pt_ct_dict_container.pt_dataset
ct_dataset = pt_ct_dict_container.ct_dataset
# Set up PT images
if 'WindowWidth' in pt_dataset[0]:
if isinstance(pt_dataset[0].WindowWidth, pydicom.valuerep.DSfloat):
window = int(pt_dataset[0].WindowWidth)
elif isinstance(pt_dataset[0].WindowWidth,
pydicom.multival.MultiValue):
window = int(pt_dataset[0].WindowWidth[1])
else:
window = int(400)
if 'WindowCenter' in pt_dataset[0]:
if isinstance(pt_dataset[0].WindowCenter, pydicom.valuerep.DSfloat):
level = int(pt_dataset[0].WindowCenter) - window / 2
elif isinstance(pt_dataset[0].WindowCenter,
pydicom.multival.MultiValue):
level = int(pt_dataset[0].WindowCenter[1]) - window / 2
else:
level = int(800)
pt_ct_dict_container.set("pt_window", window)
pt_ct_dict_container.set("pt_level", level)
if not pt_ct_dict_container.has_attribute("pt_scaled"):
pt_ct_dict_container.set("pt_scaled", True)
pt_pixel_values = convert_raw_data(pt_dataset, False, False)
else:
pt_pixel_values = convert_raw_data(pt_dataset, True)
# Calculate the ratio between x axis and y axis of 3 views
pt_pixmap_aspect = {}
pt_pixel_spacing = pt_dataset[0].PixelSpacing
pt_slice_thickness = pt_dataset[0].SliceThickness
pt_pixmap_aspect["axial"] = pt_pixel_spacing[1] / pt_pixel_spacing[0]
pt_pixmap_aspect["sagittal"] = pt_pixel_spacing[1] / pt_slice_thickness
pt_pixmap_aspect["coronal"] = pt_slice_thickness / pt_pixel_spacing[0]
# Pass in "heat" into the get_pixmaps function to produce
# a heatmap for the given images.
pt_pixmaps_axial, pt_pixmaps_coronal, pt_pixmaps_sagittal = \
get_pixmaps(pt_pixel_values, window, level, pt_pixmap_aspect,
fusion=True, color="Heat")
pt_ct_dict_container.set("pt_pixmaps_axial", pt_pixmaps_axial)
pt_ct_dict_container.set("pt_pixmaps_coronal", pt_pixmaps_coronal)
pt_ct_dict_container.set("pt_pixmaps_sagittal", pt_pixmaps_sagittal)
pt_ct_dict_container.set("pt_pixel_values", pt_pixel_values)
pt_ct_dict_container.set("pt_pixmap_aspect", pt_pixmap_aspect)
basic_info = get_basic_info(pt_dataset[0])
pt_ct_dict_container.set("pt_basic_info", basic_info)
pt_ct_dict_container.set("pt_dict_uid", dict_instance_uid(pt_dataset))
# Set up CT images
if 'WindowWidth' in ct_dataset[0]:
if isinstance(ct_dataset[0].WindowWidth, pydicom.valuerep.DSfloat):
window = int(ct_dataset[0].WindowWidth)
elif isinstance(ct_dataset[0].WindowWidth,
pydicom.multival.MultiValue):
window = int(ct_dataset[0].WindowWidth[1])
else:
window = int(400)
if 'WindowCenter' in ct_dataset[0]:
if isinstance(ct_dataset[0].WindowCenter, pydicom.valuerep.DSfloat):
level = int(ct_dataset[0].WindowCenter) - window / 2
elif isinstance(ct_dataset[0].WindowCenter,
pydicom.multival.MultiValue):
level = int(ct_dataset[0].WindowCenter[1]) - window / 2
level += CT_RESCALE_INTERCEPT
else:
level = int(800)
pt_ct_dict_container.set("ct_window", window)
pt_ct_dict_container.set("ct_level", level)
if not pt_ct_dict_container.has_attribute("ct_scaled"):
pt_ct_dict_container.set("ct_scaled", True)
ct_pixel_values = convert_raw_data(ct_dataset, False, True)
else:
ct_pixel_values = convert_raw_data(ct_dataset, True)
# Calculate the ratio between x axis and y axis of 3 views
ct_pixmap_aspect = {}
ct_pixel_spacing = ct_dataset[0].PixelSpacing
ct_slice_thickness = ct_dataset[0].SliceThickness
ct_pixmap_aspect["axial"] = ct_pixel_spacing[1] / ct_pixel_spacing[0]
ct_pixmap_aspect["sagittal"] = ct_pixel_spacing[1] / ct_slice_thickness
ct_pixmap_aspect["coronal"] = ct_slice_thickness / ct_pixel_spacing[0]
ct_pixmaps_axial, ct_pixmaps_coronal, ct_pixmaps_sagittal = \
get_pixmaps(ct_pixel_values, window, level, ct_pixmap_aspect,
fusion=True)
pt_ct_dict_container.set("ct_pixmaps_axial", ct_pixmaps_axial)
pt_ct_dict_container.set("ct_pixmaps_coronal", ct_pixmaps_coronal)
pt_ct_dict_container.set("ct_pixmaps_sagittal", ct_pixmaps_sagittal)
pt_ct_dict_container.set("ct_pixel_values", ct_pixel_values)
pt_ct_dict_container.set("ct_pixmap_aspect", ct_pixmap_aspect)
basic_info = get_basic_info(ct_dataset[0])
pt_ct_dict_container.set("ct_basic_info", basic_info)
pt_ct_dict_container.set("ct_dict_uid", dict_instance_uid(ct_dataset))
def create_moving_model():
"""
This function initializes all the attributes in the
MovingDictContainer 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 MovingDictContainer instance are set (i.e. dataset
and filepaths).
"""
##############################
# LOAD PATIENT INFORMATION #
##############################
moving_dict_container = MovingDictContainer()
dataset = moving_dict_container.dataset
filepaths = moving_dict_container.filepaths
moving_dict_container.set("rtss_modified_moving", False)
# Determine if dataset is CT for aditional rescaling
is_ct = False
if dataset[0].Modality == "CT":
is_ct = True
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) - window / 2
elif isinstance(dataset[0].WindowCenter, pydicom.multival.MultiValue):
level = int(dataset[0].WindowCenter[1]) - window / 2
if is_ct:
level += CT_RESCALE_INTERCEPT
else:
level = int(800)
moving_dict_container.set("window", window)
moving_dict_container.set("level", level)
# Check to see if the imageWindowing.csv file exists
if os.path.exists(data_path('imageWindowing.csv')):
# If it exists, read data from file into the self.dict_windowing
# variable
dict_windowing = {}
with open(data_path('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]
}
moving_dict_container.set("dict_windowing_moving", dict_windowing)
if not moving_dict_container.has_attribute("scaled"):
moving_dict_container.set("scaled", True)
pixel_values = convert_raw_data(dataset, False, is_ct)
else:
pixel_values = convert_raw_data(dataset, True)
# Calculate the ratio between x axis and y axis of 3 views
pixmap_aspect = {}
pixel_spacing = dataset[0].PixelSpacing
slice_thickness = dataset[0].SliceThickness
pixmap_aspect["axial"] = pixel_spacing[1] / pixel_spacing[0]
pixmap_aspect["sagittal"] = pixel_spacing[1] / slice_thickness
pixmap_aspect["coronal"] = slice_thickness / pixel_spacing[0]
pixmaps_axial, pixmaps_coronal, pixmaps_sagittal = \
get_pixmaps(pixel_values, window, level, pixmap_aspect)
moving_dict_container.set("pixmaps_axial", pixmaps_axial)
moving_dict_container.set("pixmaps_coronal", pixmaps_coronal)
moving_dict_container.set("pixmaps_sagittal", pixmaps_sagittal)
moving_dict_container.set("pixel_values", pixel_values)
moving_dict_container.set("pixmap_aspect", pixmap_aspect)
basic_info = get_basic_info(dataset[0])
moving_dict_container.set("basic_info", basic_info)
moving_dict_container.set("dict_uid", dict_instance_uid(dataset))
# Set RTSS attributes
if moving_dict_container.has_modality("rtss"):
moving_dict_container.set("file_rtss", filepaths['rtss'])
moving_dict_container.set("dataset_rtss", dataset['rtss'])
dicom_tree_rtss = DicomTree(filepaths['rtss'])
moving_dict_container.set("dict_dicom_tree_rtss", dicom_tree_rtss.dict)
moving_dict_container.set(
"list_roi_numbers",
ordered_list_rois(moving_dict_container.get("rois")))
moving_dict_container.set("selected_rois", [])
moving_dict_container.set("dict_polygons", {})
# Set RTDOSE attributes
if moving_dict_container.has_modality("rtdose"):
dicom_tree_rtdose = DicomTree(filepaths['rtdose'])
moving_dict_container.set("dict_dicom_tree_rtdose",
dicom_tree_rtdose.dict)
moving_dict_container.set("dose_pixluts", get_dose_pixluts(dataset))
moving_dict_container.set("selected_doses", [])
# This will be overwritten if an RTPLAN is present.
moving_dict_container.set("rx_dose_in_cgray", 1)
# Set RTPLAN attributes
if moving_dict_container.has_modality("rtplan"):
rx_dose_in_cgray = calculate_rx_dose_in_cgray(dataset["rtplan"])
moving_dict_container.set("rx_dose_in_cgray", rx_dose_in_cgray)
dicom_tree_rtplan = DicomTree(filepaths['rtplan'])
moving_dict_container.set("dict_dicom_tree_rtplan",
dicom_tree_rtplan.dict)
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 windowing_model(text, init):
"""
Function triggered when a window is selected from the menu.
:param text: The name of the window selected.
:param init: list of bool to determine which views are chosen
"""
patient_dict_container = PatientDictContainer()
moving_dict_container = MovingDictContainer()
pt_ct_dict_container = PTCTDictContainer()
# Get the values for window and level from the dict
windowing_limits = patient_dict_container.get("dict_windowing")[text]
# Set window and level to the new values
window = windowing_limits[0]
level = windowing_limits[1]
# Update the dictionary of pixmaps with the update window and
# level values
if init[0]:
pixel_values = patient_dict_container.get("pixel_values")
pixmap_aspect = patient_dict_container.get("pixmap_aspect")
pixmaps_axial, pixmaps_coronal, pixmaps_sagittal = \
get_pixmaps(pixel_values, window, level, pixmap_aspect)
patient_dict_container.set("pixmaps_axial", pixmaps_axial)
patient_dict_container.set("pixmaps_coronal", pixmaps_coronal)
patient_dict_container.set("pixmaps_sagittal", pixmaps_sagittal)
patient_dict_container.set("window", window)
patient_dict_container.set("level", level)
# Update CT
if init[2]:
ct_pixel_values = pt_ct_dict_container.get("ct_pixel_values")
ct_pixmap_aspect = pt_ct_dict_container.get("ct_pixmap_aspect")
ct_pixmaps_axial, ct_pixmaps_coronal, ct_pixmaps_sagittal = \
get_pixmaps(ct_pixel_values, window, level, ct_pixmap_aspect,
fusion=True)
pt_ct_dict_container.set("ct_pixmaps_axial", ct_pixmaps_axial)
pt_ct_dict_container.set("ct_pixmaps_coronal", ct_pixmaps_coronal)
pt_ct_dict_container.set("ct_pixmaps_sagittal", ct_pixmaps_sagittal)
pt_ct_dict_container.set("ct_window", window)
pt_ct_dict_container.set("ct_level", level)
# Update PT
if init[1]:
pt_pixel_values = pt_ct_dict_container.get("pt_pixel_values")
pt_pixmap_aspect = pt_ct_dict_container.get("pt_pixmap_aspect")
pt_pixmaps_axial, pt_pixmaps_coronal, pt_pixmaps_sagittal = \
get_pixmaps(pt_pixel_values, window, level, pt_pixmap_aspect,
fusion=True, color="Heat")
pt_ct_dict_container.set("pt_pixmaps_axial", pt_pixmaps_axial)
pt_ct_dict_container.set("pt_pixmaps_coronal", pt_pixmaps_coronal)
pt_ct_dict_container.set("pt_pixmaps_sagittal", pt_pixmaps_sagittal)
pt_ct_dict_container.set("pt_window", window)
pt_ct_dict_container.set("pt_level", level)
# Update Fusion
if init[3]:
fusion_axial, fusion_coronal, fusion_sagittal, tfm = \
get_fused_window(level, window)
patient_dict_container.set("color_axial", fusion_axial)
patient_dict_container.set("color_coronal", fusion_coronal)
patient_dict_container.set("color_sagittal", fusion_sagittal)
moving_dict_container.set("tfm", tfm)
def create_initial_model_batch():
"""
This function initializes all the attributes in the PatientDictContainer
required for the operation of batch processing. It is a modified version
of create_initial_model. This function only sets RTSS values in the
PatientDictContainer if an RTSS exists. If one does not exist it will only
be created if needed, whereas the original create_initial_model assumes
that one is always created. This function also does not set SR attributes
in the PatientDictContainer, as SRs are only needed for SR2CSV functions,
which do not require the use of the PatientDictContainer.
"""
##############################
# 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(data_path('imageWindowing.csv')):
# If it exists, read data from file into the self.dict_windowing
# variable
dict_windowing = {}
with open(data_path('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)
# Calculate the ratio between x axis and y axis of 3 views
pixmap_aspect = {}
pixel_spacing = dataset[0].PixelSpacing
slice_thickness = dataset[0].SliceThickness
pixmap_aspect["axial"] = pixel_spacing[1] / pixel_spacing[0]
pixmap_aspect["sagittal"] = pixel_spacing[1] / slice_thickness
pixmap_aspect["coronal"] = slice_thickness / pixel_spacing[0]
pixmaps_axial, pixmaps_coronal, pixmaps_sagittal = \
get_pixmaps(pixel_values, window, level, pixmap_aspect)
patient_dict_container.set("pixmaps_axial", pixmaps_axial)
patient_dict_container.set("pixmaps_coronal", pixmaps_coronal)
patient_dict_container.set("pixmaps_sagittal", pixmaps_sagittal)
patient_dict_container.set("pixel_values", pixel_values)
patient_dict_container.set("pixmap_aspect", pixmap_aspect)
basic_info = get_basic_info(dataset[0])
patient_dict_container.set("basic_info", basic_info)
patient_dict_container.set("dict_uid", dict_instance_uid(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'])
dict_raw_contour_data, dict_numpoints = \
ImageLoading.get_raw_contour_data(dataset['rtss'])
patient_dict_container.set("raw_contour", dict_raw_contour_data)
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_axial", {})
patient_dict_container.set("dict_polygons_sagittal", {})
patient_dict_container.set("dict_polygons_coronal", {})
# 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", [])
# overwritten if RTPLAN is present.
patient_dict_container.set("rx_dose_in_cgray", 1)
# 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 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)
# Determine if dataset is CT for aditional rescaling
is_ct = False
if dataset[0].Modality == "CT":
is_ct = True
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) - window / 2
elif isinstance(dataset[0].WindowCenter, pydicom.multival.MultiValue):
level = int(dataset[0].WindowCenter[1]) - window / 2
if is_ct:
level += CT_RESCALE_INTERCEPT
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(data_path('imageWindowing.csv')):
# If it exists, read data from file into the self.dict_windowing
# variable
dict_windowing = {}
with open(data_path('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)
if not patient_dict_container.has_attribute("scaled"):
patient_dict_container.set("scaled", True)
pixel_values = convert_raw_data(dataset, False, is_ct)
else:
pixel_values = convert_raw_data(dataset, True)
# Calculate the ratio between x axis and y axis of 3 views
pixmap_aspect = {}
pixel_spacing = dataset[0].PixelSpacing
slice_thickness = dataset[0].SliceThickness
pixmap_aspect["axial"] = pixel_spacing[1] / pixel_spacing[0]
pixmap_aspect["sagittal"] = pixel_spacing[1] / slice_thickness
pixmap_aspect["coronal"] = slice_thickness / pixel_spacing[0]
pixmaps_axial, pixmaps_coronal, pixmaps_sagittal = \
get_pixmaps(pixel_values, window, level, pixmap_aspect)
patient_dict_container.set("pixmaps_axial", pixmaps_axial)
patient_dict_container.set("pixmaps_coronal", pixmaps_coronal)
patient_dict_container.set("pixmaps_sagittal", pixmaps_sagittal)
patient_dict_container.set("pixel_values", pixel_values)
patient_dict_container.set("pixmap_aspect", pixmap_aspect)
basic_info = get_basic_info(dataset[0])
patient_dict_container.set("basic_info", basic_info)
patient_dict_container.set("dict_uid", dict_instance_uid(dataset))
# Set RTSS attributes
patient_dict_container.set("file_rtss", filepaths['rtss'])
patient_dict_container.set("dataset_rtss", dataset['rtss'])
dict_raw_contour_data, dict_numpoints = \
ImageLoading.get_raw_contour_data(dataset['rtss'])
patient_dict_container.set("raw_contour", dict_raw_contour_data)
# dict_dicom_tree_rtss will be set in advance if the program
# generates a new rtss through the execution of
# ROI.create_initial_rtss_from_ct(...)
if patient_dict_container.get("dict_dicom_tree_rtss") is None:
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_axial", {})
patient_dict_container.set("dict_polygons_sagittal", {})
patient_dict_container.set("dict_polygons_coronal", {})
# 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", [])
# overwritten if RTPLAN is present.
patient_dict_container.set("rx_dose_in_cgray", 1)
# 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)
# Set SR attributes
if patient_dict_container.has_modality("sr-cd"):
dicom_tree_sr_clinical_data = DicomTree(filepaths['sr-cd'])
patient_dict_container.set("dict_dicom_tree_sr_cd",
dicom_tree_sr_clinical_data.dict)
if patient_dict_container.has_modality("sr-rad"):
dicom_tree_sr_pyrad = DicomTree(filepaths['sr-rad'])
patient_dict_container.set("dict_dicom_tree_sr_pyrad",
dicom_tree_sr_pyrad.dict)