def monaco_patient_directory_picker(patient_id="",
key_namespace="",
advanced_mode_local=False,
site=None):
monaco_site, monaco_directory = misc.get_site_and_directory(
"Monaco Plan Location",
"monaco",
default=site,
key=f"{key_namespace}_monaco_site",
)
if advanced_mode_local:
st.write(monaco_directory.resolve())
patient_id = st.text_input("Patient ID",
patient_id,
key=f"{key_namespace}_patient_id")
if advanced_mode_local:
patient_id
if patient_id == "":
st.stop()
plan_directories = list(monaco_directory.glob(f"*~{patient_id}/plan"))
if len(plan_directories) == 0:
if patient_id != "":
st.write(
exceptions.NoRecordsFound(
f"No Monaco plan directories found for patient ID {patient_id}"
))
st.stop()
return {"patient_id": patient_id}
elif len(plan_directories) > 1:
raise ValueError(
"More than one patient plan directory found for this ID, "
"please only have one directory per patient. "
"Directories found were "
f"{', '.join([str(path.resolve()) for path in plan_directories])}")
plan_directory = plan_directories[0]
patient_directory = pathlib.Path(plan_directory).parent
return monaco_site, monaco_directory, patient_id, plan_directory, patient_directory
def user_input():
result = st.text_input(label=server, type=input_type)
if not result:
st.stop()
return result
def main():
st.write("# Anonymise Monaco Files")
st.write("## Select Patient")
(
monaco_site,
_,
patient_id,
_,
patient_directory,
) = st_monaco.monaco_patient_directory_picker(advanced_mode_local=True)
st.write(f"Directory to anonymise: `{patient_directory}`")
st.write("## Select Export Location")
_, export_directory = st_misc.get_site_and_directory(
"Site to save anonymised zip file",
"anonymised_monaco",
default=monaco_site,
key="export_site",
)
st.write(f"Export directory: `{export_directory}`")
zip_path = pathlib.Path(export_directory).joinpath(f"{patient_id}.zip")
st.write(f"Zip file to be created: `{zip_path}`")
if zip_path.exists():
st.write(FileExistsError("This zip file already exists."))
if st.button("Delete zip file"):
zip_path.unlink()
st_rerun.rerun()
st.stop()
if st.button("Copy and Anonymise"):
with tempfile.TemporaryDirectory() as temp_dir:
pl_temp_dir = pathlib.Path(temp_dir)
new_temp_location = pl_temp_dir.joinpath(patient_directory.name)
st.write("Copying to temp directory, skipping DICOM files...")
shutil.copytree(
patient_directory,
new_temp_location,
ignore=shutil.ignore_patterns("*.DCM", "demographic.*"),
)
st.write("Creating anonymised demographic file...")
new_demographic_file = new_temp_location.joinpath(
f"demographic.{patient_id}"
)
shutil.copy2(ANON_DEMOGRAPHIC_FILE, new_demographic_file)
with open(new_demographic_file, "r") as f:
demographic_data = f.readlines()
demographic_data[3] = demographic_data[3].replace("000000", patient_id)
with open(new_demographic_file, "w") as f:
f.writelines(demographic_data)
st.write("Creating zip file...")
shutil.make_archive(
str(zip_path.with_suffix("")),
"zip",
root_dir=str(pl_temp_dir.resolve()),
base_dir=f"{patient_directory.name}",
)
st.write("Complete!")
def main():
st.write("""
# Electron Insert Factors
""")
patient_id = st.text_input("Patient ID")
if patient_id == "":
st.stop()
rccc_string_search_pattern = r"\\monacoda\FocalData\RCCC\1~Clinical\*~{}\plan\*\*tel.1".format(
patient_id)
rccc_filepath_list = glob(rccc_string_search_pattern)
nbccc_string_search_pattern = r"\\tunnel-nbcc-monaco\FOCALDATA\NBCCC\1~Clinical\*~{}\plan\*\*tel.1".format(
patient_id)
nbccc_filepath_list = glob(nbccc_string_search_pattern)
sash_string_search_pattern = r"\\tunnel-sash-monaco\Users\Public\Documents\CMS\FocalData\SASH\1~Clinical\*~{}\plan\*\*tel.1".format(
patient_id)
sash_filepath_list = glob(sash_string_search_pattern)
filepath_list = np.concatenate(
[rccc_filepath_list, nbccc_filepath_list, sash_filepath_list])
electronmodel_regex = r"RiverinaAgility - (\d+)MeV"
applicator_regex = r"(\d+)X\d+"
insert_data = dict() # type: ignore
for telfilepath in filepath_list:
insert_data[telfilepath] = dict()
with open(telfilepath, "r") as file:
telfilecontents = np.array(file.read().splitlines())
insert_data[telfilepath]["reference_index"] = []
for i, item in enumerate(telfilecontents):
if re.search(electronmodel_regex, item):
insert_data[telfilepath]["reference_index"] += [i]
insert_data[telfilepath]["applicators"] = [
re.search(applicator_regex,
telfilecontents[i + 12]).group(1) # type: ignore
for i in insert_data[telfilepath]["reference_index"]
]
insert_data[telfilepath]["energies"] = [
re.search(electronmodel_regex,
telfilecontents[i]).group(1) # type: ignore
for i in insert_data[telfilepath]["reference_index"]
]
for telfilepath in filepath_list:
with open(telfilepath, "r") as file:
telfilecontents = np.array(file.read().splitlines())
insert_data[telfilepath]["x"] = []
insert_data[telfilepath]["y"] = []
for i, index in enumerate(insert_data[telfilepath]["reference_index"]):
insert_initial_range = telfilecontents[
index +
51::] # coords start 51 lines after electron model name
insert_stop = np.where(insert_initial_range == "0")[0][
0] # coords stop right before a line containing 0
insert_coords_string = insert_initial_range[:insert_stop]
insert_coords = np.fromstring(",".join(insert_coords_string),
sep=",")
insert_data[telfilepath]["x"].append(insert_coords[0::2] / 10)
insert_data[telfilepath]["y"].append(insert_coords[1::2] / 10)
for telfilepath in filepath_list:
insert_data[telfilepath]["width"] = []
insert_data[telfilepath]["length"] = []
insert_data[telfilepath]["circle_centre"] = []
insert_data[telfilepath]["P/A"] = []
for i in range(len(insert_data[telfilepath]["reference_index"])):
width, length, circle_centre = electronfactors.parameterise_insert(
insert_data[telfilepath]["x"][i],
insert_data[telfilepath]["y"][i])
insert_data[telfilepath]["width"].append(width)
insert_data[telfilepath]["length"].append(length)
insert_data[telfilepath]["circle_centre"].append(circle_centre)
insert_data[telfilepath]["P/A"].append(
electronfactors.convert2_ratio_perim_area(width, length))
data_filename = r"S:\Physics\RCCC Specific Files\Dosimetry\Elekta_EFacs\electron_factor_measured_data.csv"
data = pd.read_csv(data_filename)
width_data = data["Width (cm @ 100SSD)"]
length_data = data["Length (cm @ 100SSD)"]
factor_data = data["RCCC Inverse factor (dose open / dose cutout)"]
p_on_a_data = electronfactors.convert2_ratio_perim_area(
width_data, length_data)
for telfilepath in filepath_list:
insert_data[telfilepath]["model_factor"] = []
for i in range(len(insert_data[telfilepath]["reference_index"])):
applicator = float(insert_data[telfilepath]["applicators"][i])
energy = float(insert_data[telfilepath]["energies"][i])
ssd = 100
reference = ((data["Energy (MeV)"] == energy)
& (data["Applicator (cm)"] == applicator)
& (data["SSD (cm)"] == ssd))
number_of_measurements = np.sum(reference)
if number_of_measurements < 8:
insert_data[telfilepath]["model_factor"].append(np.nan)
else:
insert_data[telfilepath]["model_factor"].append(
electronfactors.spline_model_with_deformability(
insert_data[telfilepath]["width"],
insert_data[telfilepath]["P/A"],
width_data[reference],
p_on_a_data[reference],
factor_data[reference],
)[0])
for telfilepath in filepath_list:
st.write("---")
st.write("Filepath: `{}`".format(telfilepath))
for i in range(len(insert_data[telfilepath]["reference_index"])):
applicator = float(insert_data[telfilepath]["applicators"][i])
energy = float(insert_data[telfilepath]["energies"][i])
ssd = 100
st.write("Applicator: `{} cm` | Energy: `{} MeV`".format(
applicator, energy))
width = insert_data[telfilepath]["width"][i]
length = insert_data[telfilepath]["length"][i]
plt.figure()
plot_insert(
insert_data[telfilepath]["x"][i],
insert_data[telfilepath]["y"][i],
insert_data[telfilepath]["width"][i],
insert_data[telfilepath]["length"][i],
insert_data[telfilepath]["circle_centre"][i],
)
reference = ((data["Energy (MeV)"] == energy)
& (data["Applicator (cm)"] == applicator)
& (data["SSD (cm)"] == ssd))
number_of_measurements = np.sum(reference)
plt.figure()
if number_of_measurements < 8:
plt.scatter(
width_data[reference],
length_data[reference],
s=100,
c=factor_data[reference],
cmap="viridis",
zorder=2,
)
plt.colorbar()
else:
plot_model(
width_data[reference],
length_data[reference],
factor_data[reference],
)
reference_data_table = pd.concat(
[
width_data[reference], length_data[reference],
factor_data[reference]
],
axis=1,
)
reference_data_table.sort_values(
["RCCC Inverse factor (dose open / dose cutout)"],
ascending=False,
inplace=True,
)
st.write(reference_data_table)
st.pyplot()
factor = insert_data[telfilepath]["model_factor"][i]
st.write(
"Width: `{0:0.2f} cm` | Length: `{1:0.2f} cm` | Factor: `{2:0.3f}`"
.format(width, length, factor))
def icom_input_method(patient_id="",
key_namespace="",
advanced_mode_local=False,
**_):
icom_directories = _config.get_default_icom_directories()
if advanced_mode_local:
st.write("iCOM patient directories", icom_directories)
icom_directories = [pathlib.Path(path) for path in icom_directories]
if advanced_mode_local:
patient_id = st.text_input("Patient ID",
patient_id,
key=f"{key_namespace}_patient_id")
st.write(patient_id)
icom_deliveries = []
for path in icom_directories:
icom_deliveries += list(path.glob(f"{patient_id}_*/*.xz"))
icom_deliveries = sorted(icom_deliveries)
icom_files_to_choose_from = [path.stem for path in icom_deliveries]
timestamps = list(
pd.to_datetime(icom_files_to_choose_from,
format="%Y%m%d_%H%M%S").astype(str))
choice_path_map = dict(zip(timestamps, icom_deliveries))
st.write("""
Here you need to select the timestamps that correspond to a single
fraction of the plan selected above. Most of the time
you will only need to select one timestamp here, however in some
cases you may need to select multiple timestamps.
This can occur if for example a single fraction was delivered in separate
beams due to either a beam interrupt, or the fraction being spread
over multiple energies
""")
if len(timestamps) == 0:
if patient_id != "":
st.write(
_exceptions.NoRecordsFound(
f"No iCOM delivery record found for patient ID {patient_id}"
))
return {"patient_id": patient_id}
if len(timestamps) == 1:
default_timestamp = [timestamps[0]]
else:
default_timestamp = []
timestamps = sorted(timestamps, reverse=True)
try:
selected_icom_deliveries = st.multiselect(
"Select iCOM delivery timestamp(s)",
timestamps,
default=default_timestamp,
key=f"{key_namespace}_icom_deliveries",
)
except st.errors.StreamlitAPIException:
st.write(f"Default timestamp = `{default_timestamp}`")
st.write(f"All timestamps = `{timestamps}`")
raise
icom_filenames = [
path.replace(" ", "_").replace("-", "").replace(":", "")
for path in selected_icom_deliveries
]
icom_paths = []
for selected in selected_icom_deliveries:
icom_paths.append(choice_path_map[selected])
if advanced_mode_local:
st.write([str(path.resolve()) for path in icom_paths])
patient_names = set()
for icom_path in icom_paths:
patient_name = str(icom_path.parent.name).split("_")[-1]
try:
patient_name = utl_patient.convert_patient_name_from_split(
*patient_name.split(", "))
except: # pylint: disable = bare-except
pass
patient_names.add(patient_name)
patient_name = _utilities.filter_patient_names(patient_names)
icom_streams = load_icom_streams(icom_paths)
deliveries = _deliveries.cached_deliveries_loading(
icom_streams, _deliveries.delivery_from_icom)
if selected_icom_deliveries:
identifier = f"iCOM ({icom_filenames[0]})"
else:
identifier = None
if len(deliveries) == 0:
st.write(
_exceptions.InputRequired(
"Please select at least one iCOM delivery"))
st.stop()
results = {
"site": None,
"patient_id": patient_id,
"patient_name": patient_name,
"selected_icom_deliveries": selected_icom_deliveries,
"data_paths": icom_paths,
"identifier": identifier,
"deliveries": deliveries,
}
return results