def convert_IEC_angle_to_bipolar(angle):
angle = np.copy(angle)
if np.all(angle == 180):
return angle
angle[angle > 180] = angle[angle > 180] - 360
is_180 = np.where(angle == 180)[0]
not_180 = np.where(np.invert(angle == 180))[0]
where_closest_left_leaning = np.argmin(np.abs(is_180[:, None] -
not_180[None, :]),
axis=1)
where_closest_right_leaning = (len(not_180) - 1 - np.argmin(
np.abs(is_180[::-1, None] - not_180[None, ::-1]), axis=1)[::-1])
closest_left_leaning = not_180[where_closest_left_leaning]
closest_right_leaning = not_180[where_closest_right_leaning]
assert np.all(
np.sign(angle[closest_left_leaning]) == np.sign(
angle[closest_right_leaning])
), "Unable to automatically determine whether angle is 180 or -180"
angle[is_180] = np.sign(angle[closest_left_leaning]) * angle[is_180]
return angle
def normalise(
distance,
relative_dose,
scan_curvetype,
scan_depth,
pdd_normalisation_depth=None,
profile_normalisation_position=None,
scale_to_pdd=False,
smoothed_normalisation=False,
):
"""Take a series of PDDs and/or profiles and normalise them according to
a range of available options.
"""
# Convert scan_curvetype to a numpy array
scan_curvetype = np.array(scan_curvetype)
# Find the references of PDDs and profiles
ref_of_pdd = np.where(scan_curvetype == "PDD")[0]
ref_of_profile = np.where((scan_curvetype == "INPLANE_PROFILE")
| (scan_curvetype == "CROSSPLANE_PROFILE"))[0]
# Step through each PDD and normalise them
for i in ref_of_pdd:
relative_dose[i] = normalise_pdd(
relative_dose[i],
depth=distance[i],
normalisation_depth=pdd_normalisation_depth,
)
# If user requested scaling to PDD run "normalise" profile with relevant
# options
if scale_to_pdd:
pdd_distance = distance[ref_of_pdd[0]]
pdd_relative_dose = relative_dose[ref_of_pdd[0]]
for i in ref_of_profile:
relative_dose[i] = normalise_profile(
distance[i],
relative_dose[i],
pdd_distance=pdd_distance,
pdd_relative_dose=pdd_relative_dose,
scan_depth=scan_depth[i],
normalisation_position=profile_normalisation_position,
smoothed_normalisation=smoothed_normalisation,
scale_to_pdd=True,
)
# If user did not request PDD scaling run normalise_profile with basic
# options
else:
for i in ref_of_profile:
relative_dose[i] = normalise_profile(
distance[i],
relative_dose[i],
normalisation_position=profile_normalisation_position,
smoothed_normalisation=smoothed_normalisation,
)
return relative_dose
def dose_inside_cube(x_dose, y_dose, z_dose, dose, cube):
"""Find the dose just within the given cube.
"""
cube_definition = cubify(cube)
print(cube_definition)
vertices = cube_vertices(cube_definition)
bounding_box = get_bounding_box(vertices)
x_outside = (x_dose < bounding_box[1][0]) | (x_dose > bounding_box[1][1])
y_outside = (y_dose < bounding_box[0][0]) | (y_dose > bounding_box[0][1])
z_outside = (z_dose < bounding_box[2][0]) | (z_dose > bounding_box[2][1])
xx, yy, zz = np.meshgrid(
x_dose[np.invert(x_outside)],
y_dose[np.invert(y_outside)],
z_dose[np.invert(z_outside)],
)
where_x = np.where(np.invert(x_outside))[0]
where_y = np.where(np.invert(y_outside))[0]
where_z = np.where(np.invert(z_outside))[0]
bounded_dose = dose[
where_y[0] : where_y[-1] + 1,
where_x[0] : where_x[-1] + 1,
where_z[0] : where_z[-1] + 1,
]
points_to_test = np.array(
[
[y, x, z, d]
for y, x, z, d in zip(
np.ravel(yy), np.ravel(xx), np.ravel(zz), np.ravel(bounded_dose)
)
]
)
inside_cube = [
test_if_in_cube(point_test, cube_definition)
for point_test in points_to_test[:, 0:3]
]
points_inside_cube = points_to_test[inside_cube, :]
ax = plot_cube(cube_definition)
ax.scatter(
points_inside_cube[:, 1],
points_inside_cube[:, 0],
points_inside_cube[:, 2],
c=points_inside_cube[:, 3],
alpha=0.4,
)
return ax
def _convert_to_full_grid(grid, full_grid, mu_density):
grid_xx, grid_yy = np.meshgrid(grid["mlc"], grid["jaw"])
full_grid_xx, full_grid_yy = np.meshgrid(full_grid["mlc"],
full_grid["jaw"])
xx_from, xx_to = np.where(
np.abs(full_grid_xx[None, 0, :] - grid_xx[0, :, None]) < 0.0001)
yy_from, yy_to = np.where(
np.abs(full_grid_yy[None, :, 0] - grid_yy[:, 0, None]) < 0.0001)
full_grid_mu_density = np.zeros_like(full_grid_xx)
full_grid_mu_density[ # pylint: disable=unsupported-assignment-operation
np.ix_(yy_to, xx_to)] = mu_density[np.ix_(yy_from, xx_from)]
return full_grid_mu_density
def create_bb_to_minimise(field, bb_diameter):
"""This is a numpy vectorised version of `create_bb_to_minimise_simple`
"""
points_to_check_edge_agreement, dist = interppoints.create_bb_points_function(
bb_diameter)
dist_mask = np.unique(dist)[:, None] == dist[None, :]
num_in_mask = np.sum(dist_mask, axis=1)
mask_count_per_item = np.sum(num_in_mask[:, None] * dist_mask, axis=0)
mask_mean_lookup = np.where(dist_mask)[0]
def to_minimise_edge_agreement(centre):
x, y = points_to_check_edge_agreement(centre)
results = field(x, y)
masked_results = results * dist_mask
mask_mean = np.sum(masked_results, axis=1) / num_in_mask
diff_to_mean_square = (results - mask_mean[mask_mean_lookup])**2
mean_of_layers = np.sum(
diff_to_mean_square[1::] /
mask_count_per_item[1::]) / (len(mask_mean) - 1)
return mean_of_layers
return to_minimise_edge_agreement
def get_dose_grid_structure_mask(structure_name, dcm_struct, dcm_dose):
x_dose, y_dose, z_dose = xyz_axes_from_dataset(dcm_dose)
xx_dose, yy_dose = np.meshgrid(x_dose, y_dose)
points = np.swapaxes(np.vstack([xx_dose.ravel(), yy_dose.ravel()]), 0, 1)
x_structure, y_structure, z_structure = pull_structure(
structure_name, dcm_struct)
structure_z_values = np.array([item[0] for item in z_structure])
mask = np.zeros((len(y_dose), len(x_dose), len(z_dose)), dtype=bool)
for z_val in structure_z_values:
structure_indices = _get_indices(z_structure, z_val)
for structure_index in structure_indices:
dose_index = int(np.where(z_dose == z_val)[0])
assert z_structure[structure_index][0] == z_dose[dose_index]
structure_polygon = matplotlib.path.Path([
(x_structure[structure_index][i],
y_structure[structure_index][i])
for i in range(len(x_structure[structure_index]))
])
mask[:, :, dose_index] = mask[:, :, dose_index] | (
structure_polygon.contains_points(points).reshape(
len(y_dose), len(x_dose)))
return mask
def _get_indices(z_list, z_val):
indices = np.array([item[0] for item in z_list])
# This will error if more than one contour exists on a given slice
desired_indices = np.where(indices == z_val)[0]
# Multiple contour sets per slice not yet implemented
return desired_indices
def group_consecutive_logfiles(file_hashes, index):
times = np.array([index[key]["local_time"]
for key in file_hashes]).astype(np.datetime64)
sort_reference = np.argsort(times)
file_hashes = file_hashes[sort_reference]
times = times[sort_reference]
hours_4 = np.array(60 * 60 * 4).astype(np.timedelta64)
split_locations = np.where(np.diff(times) >= hours_4)[0] + 1
return np.split(file_hashes, split_locations)
def as_binary(self, threshold: int):
"""Return a binary (black & white) image based on the given threshold.
Parameters
----------
threshold : int, float
The threshold value. If the value is above or equal to the threshold it is set to 1, otherwise to 0.
Returns
-------
ArrayImage
"""
array = np.where(self.array >= threshold, 1, 0)
return ArrayImage(array)
def convert_numbers_to_string(name, lookup, column):
dtype = np.array([item for _, item in lookup.items()]).dtype
result = np.empty_like(column).astype(dtype)
result[:] = ""
for i, item in lookup.items():
result[column.values == int(i)] = item
if np.any(result == ""):
print(lookup)
print(np.where(result == ""))
print(column[result == ""].values)
unconverted_entries = np.unique(column[result == ""])
raise Exception(
"The conversion lookup list for converting {} is incomplete. "
"The following data numbers were not converted:\n"
"{}\n"
"Please update the trf2csv conversion script to include these "
"in its definitions.".format(name, unconverted_entries))
return result
def gamma_filter_numpy(axes_reference,
dose_reference,
axes_evaluation,
dose_evaluation,
distance_mm_threshold,
dose_threshold,
lower_dose_cutoff=0,
**_):
coord_diffs = [
coord_ref[:, None] - coord_eval[None, :]
for coord_ref, coord_eval in zip(axes_reference, axes_evaluation)
]
all_in_vicinity = [
np.where(np.abs(diff) < distance_mm_threshold) for diff in coord_diffs
]
ref_coord_points = create_point_combination(
[in_vicinity[0] for in_vicinity in all_in_vicinity])
eval_coord_points = create_point_combination(
[in_vicinity[1] for in_vicinity in all_in_vicinity])
distances = np.sqrt(
np.sum(
[
coord_diff[ref_points, eval_points]**2
for ref_points, eval_points, coord_diff in zip(
ref_coord_points, eval_coord_points, coord_diffs)
],
axis=0,
))
within_distance_threshold = distances < distance_mm_threshold
distances = distances[within_distance_threshold]
ref_coord_points = ref_coord_points[:, within_distance_threshold]
eval_coord_points = eval_coord_points[:, within_distance_threshold]
dose_diff = (
dose_evaluation[eval_coord_points[0, :], eval_coord_points[1, :],
eval_coord_points[2, :]] -
dose_reference[ref_coord_points[0, :], ref_coord_points[1, :],
ref_coord_points[2, :]])
gamma = np.sqrt((dose_diff / dose_threshold)**2 +
(distances / distance_mm_threshold)**2)
gamma_pass = gamma < 1
eval_pass = eval_coord_points[:, gamma_pass]
ravel_index = convert_to_ravel_index(eval_pass)
gamma_pass_array = np.zeros_like(dose_evaluation).astype(np.bool)
gamma_pass_array = np.ravel(gamma_pass_array)
dose_above_cut_off = np.ravel(dose_evaluation) > lower_dose_cutoff
gamma_pass_array[ravel_index] = True
gamma_pass_percentage = np.mean(gamma_pass_array[dose_above_cut_off]) * 100
return gamma_pass_percentage
def _gantry_angle_mask(self, gantry_angle, gantry_angle_tol):
near_angle = np.abs(np.array(self.gantry) -
gantry_angle) <= gantry_angle_tol
assert np.all(np.diff(np.where(near_angle)[0]) == 1)
return near_angle
def load_mephysto(filepath,
output_to_file=False,
output_directory=None,
sort=True):
"""Input the filepath of a mephysto .mcc file and return the data of the
scans in four lists, distance, relative_dose, scan_curvetype, and
scan_depth. Each respective element in these lists corresponds to an
individual scan.
"""
# Open the file and store the contents in file_contents
with open(filepath) as file_pointer:
file_contents = np.array(file_pointer.readlines())
# Use the functions defined within mccread.py to pull the desired data
distance, relative_dose = pull_mephysto_data(file_contents)
scan_curvetype = pull_mephysto_item("SCAN_CURVETYPE", file_contents)
scan_depth = pull_mephysto_number("SCAN_DEPTH", file_contents)
# Convert python lists into numpy arrays for easier use
distance = np.array(distance, dtype=object)
relative_dose = np.array(relative_dose, dtype=object)
scan_curvetype = np.array(scan_curvetype)
scan_depth = np.array(scan_depth)
# If the user requests to sort the data (which is default) the loaded
# mephysto files are organised so that PDDs are first, then inplane
# profiles, then crossplane profiles.
if sort:
# Find the references for where the scan type is the relevant type
# and then use the "hstack" function to join the references together.
sort_ref = np.hstack([
np.where(scan_curvetype == "PDD")[0], # reference of PDDs
np.where(scan_curvetype == "INPLANE_PROFILE")[0], # inplane ref
np.where(scan_curvetype == "CROSSPLANE_PROFILE")[0], # crossplane
])
# Confirm that the length of sort_ref is the same as scan_curvetype.
# This will be false if there exists an unexpected scan_curvetype.
assert len(sort_ref) == len(scan_curvetype)
# Apply the sorting reference to each of the relevant variables.
distance = distance[sort_ref]
relative_dose = relative_dose[sort_ref]
scan_curvetype = scan_curvetype[sort_ref]
scan_depth = scan_depth[sort_ref]
# Output csv's if "output_to_file" is True
if output_to_file:
# If user didn't define an output_directory use a default one
if output_directory is None:
# Define output directory as a mephysto folder
filepath_directory = os.path.dirname(filepath)
filename = os.path.splitext(os.path.basename(filepath))[0]
output_directory = os.path.join(filepath_directory, filename)
# If the output directory does not exist create it
if not os.path.exists(output_directory):
os.makedirs(output_directory)
# Call the file_output function within csvoutput.py
file_output(output_directory, distance, relative_dose, scan_curvetype,
scan_depth)
return distance, relative_dose, scan_curvetype, scan_depth
def from_user_inputs(
cls,
axes_reference,
dose_reference,
axes_evaluation,
dose_evaluation,
dose_percent_threshold,
distance_mm_threshold,
lower_percent_dose_cutoff=20,
interp_fraction=10,
max_gamma=None,
local_gamma=False,
global_normalisation=None,
skip_once_passed=False,
random_subset=None,
ram_available=None,
quiet=False,
):
if max_gamma is None:
max_gamma = np.inf
axes_reference, axes_evaluation = run_input_checks(
axes_reference, dose_reference, axes_evaluation, dose_evaluation)
dose_percent_threshold = expand_dims_to_1d(dose_percent_threshold)
distance_mm_threshold = expand_dims_to_1d(distance_mm_threshold)
if global_normalisation is None:
global_normalisation = np.max(dose_reference)
lower_dose_cutoff = lower_percent_dose_cutoff / 100 * global_normalisation
maximum_test_distance = np.max(distance_mm_threshold) * max_gamma
evaluation_interpolation = scipy.interpolate.RegularGridInterpolator(
axes_evaluation,
np.array(dose_evaluation),
bounds_error=False,
fill_value=np.inf,
)
dose_reference = np.array(dose_reference)
reference_dose_above_threshold = dose_reference >= lower_dose_cutoff
mesh_axes_reference = np.meshgrid(*axes_reference, indexing="ij")
flat_mesh_axes_reference = np.array(
[np.ravel(item) for item in mesh_axes_reference])
reference_points_to_calc = reference_dose_above_threshold
reference_points_to_calc = np.ravel(reference_points_to_calc)
if random_subset is not None:
to_calc_index = np.where(reference_points_to_calc)[0]
np.random.shuffle(to_calc_index)
random_subset_to_calc = np.full_like(reference_points_to_calc,
False,
dtype=bool)
random_subset_to_calc[ # pylint: disable=unsupported-assignment-operation
to_calc_index[0:random_subset]] = True
reference_points_to_calc = random_subset_to_calc
flat_dose_reference = np.ravel(dose_reference)
return cls(
flat_mesh_axes_reference,
flat_dose_reference,
reference_points_to_calc,
dose_percent_threshold,
distance_mm_threshold,
evaluation_interpolation,
interp_fraction,
max_gamma,
lower_dose_cutoff,
maximum_test_distance,
global_normalisation,
local_gamma,
skip_once_passed,
ram_available,
quiet,
)
def calc_mu_density(
mu,
mlc,
jaw,
grid_resolution=None,
max_leaf_gap=None,
leaf_pair_widths=None,
min_step_per_pixel=None,
):
"""Determine the MU Density.
Both jaw and mlc positions are defined in bipolar format for each control
point. A negative value indicates travel over the isocentre. All positional
arguments are defined at the isocentre projection with the units of mm.
Parameters
----------
mu : numpy.ndarray
1-D array containing an MU value for each control point.
mlc : numpy.ndarray
3-D array containing the MLC positions
| axis 0: control point
| axis 1: mlc pair
| axis 2: leaf bank
jaw : numpy.ndarray
2-D array containing the jaw positions.
| axis 0: control point
| axis 1: diaphragm
grid_resolution : float, optional
The calc grid resolution. Defaults to 1 mm.
max_leaf_gap : float, optional
The maximum possible distance between opposing leaves. Defaults to
400 mm.
leaf_pair_widths : tuple, optional
The widths of each leaf pair in the
MLC limiting device. The number of entries in the tuples defines
the number of leaf pairs. Each entry itself defines that particular
leaf pair width. Defaults to 80 leaf pairs each 5 mm wide.
min_step_per_pixel : int, optional
The minimum number of time steps
used per pixel for each control point. Defaults to 10.
Returns
-------
mu_density : numpy.ndarray
2-D array containing the calculated mu density.
| axis 0: jaw direction
| axis 1: mlc direction
Examples
--------
>>> import numpy as np
>>> import pymedphys
>>>
>>> leaf_pair_widths = (5, 5, 5)
>>> max_leaf_gap = 10
>>> mu = np.array([0, 2, 5, 10])
>>> mlc = np.array([
... [
... [1, 1],
... [2, 2],
... [3, 3]
... ],
... [
... [2, 2],
... [3, 3],
... [4, 4]
... ],
... [
... [-2, 3],
... [-2, 4],
... [-2, 5]
... ],
... [
... [0, 0],
... [0, 0],
... [0, 0]
... ]
... ])
>>> jaw = np.array([
... [7.5, 7.5],
... [7.5, 7.5],
... [-2, 7.5],
... [0, 0]
... ])
>>>
>>> grid = pymedphys.mudensity.grid(
... max_leaf_gap=max_leaf_gap, leaf_pair_widths=leaf_pair_widths)
>>> grid['mlc']
array([-5., -4., -3., -2., -1., 0., 1., 2., 3., 4., 5.])
>>>
>>> grid['jaw']
array([-8., -7., -6., -5., -4., -3., -2., -1., 0., 1., 2., 3., 4.,
5., 6., 7., 8.])
>>>
>>> mu_density = pymedphys.mudensity.calculate(
... mu, mlc, jaw, max_leaf_gap=max_leaf_gap,
... leaf_pair_widths=leaf_pair_widths)
>>> pymedphys.mudensity.display(grid, mu_density)
>>>
>>> np.round(mu_density, 1)
array([[0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ],
[0. , 0. , 0. , 0.3, 1.9, 2.2, 1.9, 0.4, 0. , 0. , 0. ],
[0. , 0. , 0. , 0.4, 2.2, 2.5, 2.2, 0.6, 0. , 0. , 0. ],
[0. , 0. , 0. , 0.4, 2.4, 2.8, 2.5, 0.8, 0. , 0. , 0. ],
[0. , 0. , 0. , 0.4, 2.5, 3.1, 2.8, 1. , 0. , 0. , 0. ],
[0. , 0. , 0. , 0.4, 2.5, 3.4, 3.1, 1.3, 0. , 0. , 0. ],
[0. , 0. , 0.4, 2.3, 3.2, 3.7, 3.7, 3.5, 1.6, 0. , 0. ],
[0. , 0. , 0.4, 2.3, 3.2, 3.8, 4. , 3.8, 1.9, 0.1, 0. ],
[0. , 0. , 0.4, 2.3, 3.2, 3.8, 4.3, 4.1, 2.3, 0.1, 0. ],
[0. , 0. , 0.4, 2.3, 3.2, 3.9, 5.2, 4.7, 2.6, 0.2, 0. ],
[0. , 0. , 0.4, 2.3, 3.2, 3.8, 5.4, 6.6, 3.8, 0.5, 0. ],
[0. , 0.3, 2.2, 3. , 3.5, 4. , 5.1, 7.5, 6.7, 3.9, 0.5],
[0. , 0.3, 2.2, 3. , 3.5, 4. , 4.7, 6.9, 6.7, 3.9, 0.5],
[0. , 0.3, 2.2, 3. , 3.5, 4. , 4.5, 6.3, 6.4, 3.9, 0.5],
[0. , 0.3, 2.2, 3. , 3.5, 4. , 4.5, 5.6, 5.7, 3.8, 0.5],
[0. , 0.3, 2.2, 3. , 3.5, 4. , 4.5, 5.1, 5.1, 3.3, 0.5],
[0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ]])
MU Density from a Mosaiq record
>>> import pymedphys
>>>
>>> def mu_density_from_mosaiq(msq_server_name, field_id):
... with pymedphys.mosaiq.connect(msq_server_name) as cursor:
... delivery = pymedphys.Delivery.from_mosaiq(cursor, field_id)
...
... grid = pymedphys.mudensity.grid()
... mu_density = delivery.mudensity()
... pymedphys.mudensity.display(grid, mu_density)
>>>
>>> mu_density_from_mosaiq('a_server_name', 11111) # doctest: +SKIP
MU Density from a logfile at a given filepath
>>> import pymedphys
>>>
>>> def mu_density_from_logfile(filepath):
... delivery_data = Delivery.from_logfile(filepath)
... mu_density = Delivery.mudensity()
...
... grid = pymedphys.mudensity.grid()
... pymedphys.mudensity.display(grid, mu_density)
>>>
>>> mu_density_from_logfile(r"a/path/goes/here") # doctest: +SKIP
"""
if grid_resolution is None:
grid_resolution = __DEFAULT_GRID_RESOLUTION
if max_leaf_gap is None:
max_leaf_gap = __DEFAULT_MAX_LEAF_GAP
if leaf_pair_widths is None:
leaf_pair_widths = __DEFAULT_LEAF_PAIR_WIDTHS
if min_step_per_pixel is None:
min_step_per_pixel = __DEFAULT_MIN_STEP_PER_PIXEL
divisibility_of_max_leaf_gap = np.array(max_leaf_gap / 2 / grid_resolution)
max_leaf_gap_is_divisible = (
divisibility_of_max_leaf_gap.astype(int) == divisibility_of_max_leaf_gap
)
if not max_leaf_gap_is_divisible:
raise ValueError(
"The grid resolution needs to be able to divide the max leaf gap exactly by"
" four"
)
leaf_pair_widths = np.array(leaf_pair_widths)
if not np.max(np.abs(mlc)) <= max_leaf_gap / 2: # pylint: disable = unneeded-not
first_failing_control_point = np.where(np.abs(mlc) > max_leaf_gap / 2)[0][0]
raise ValueError(
"The mlc should not travel further out than half the maximum leaf gap.\n"
"The first failing control point has the following positions:\n"
f"{np.array(mlc)[first_failing_control_point, :, :]}"
)
mu, mlc, jaw = remove_irrelevant_control_points(mu, mlc, jaw)
full_grid = get_grid(max_leaf_gap, grid_resolution, leaf_pair_widths)
mu_density = np.zeros((len(full_grid["jaw"]), len(full_grid["mlc"])))
for i in range(len(mu) - 1):
control_point_slice = slice(i, i + 2, 1)
current_mlc = mlc[control_point_slice, :, :]
current_jaw = jaw[control_point_slice, :]
delivered_mu = np.diff(mu[control_point_slice])
grid, mu_density_of_slice = calc_single_control_point(
current_mlc,
current_jaw,
delivered_mu,
leaf_pair_widths=leaf_pair_widths,
grid_resolution=grid_resolution,
min_step_per_pixel=min_step_per_pixel,
)
full_grid_mu_density_of_slice = _convert_to_full_grid(
grid, full_grid, mu_density_of_slice
)
mu_density += full_grid_mu_density_of_slice
return mu_density
def calculate_min_dose_difference(options, distance, to_be_checked,
distance_step_size):
"""Determine the minimum dose difference.
Calculated for a given distance from each reference point.
"""
min_relative_dose_difference = np.nan * np.ones_like(
options.flat_dose_reference[to_be_checked])
num_dimensions = np.shape(options.flat_mesh_axes_reference)[0]
coordinates_at_distance_shell = pymedphys._utilities.createshells.calculate_coordinates_shell( # pylint: disable = protected-access
distance, num_dimensions, distance_step_size)
num_points_in_shell = np.shape(coordinates_at_distance_shell)[1]
estimated_ram_needed = (np.uint64(num_points_in_shell) *
np.uint64(np.count_nonzero(to_be_checked)) *
np.uint64(32) * np.uint64(num_dimensions) *
np.uint64(2))
num_slices = np.floor(
estimated_ram_needed / options.ram_available).astype(int) + 1
if not options.quiet:
sys.stdout.write(
" | Points tested per reference point: {} | RAM split count: {}".
format(num_points_in_shell, num_slices))
sys.stdout.flush()
all_checks = np.where(np.ravel(to_be_checked))[0]
index = np.arange(len(all_checks))
sliced = np.array_split(index, num_slices)
sorted_sliced = [np.sort(current_slice) for current_slice in sliced]
for current_slice in sorted_sliced:
to_be_checked_sliced = np.full_like(to_be_checked, False, dtype=bool)
to_be_checked_sliced[ # pylint: disable=unsupported-assignment-operation
all_checks[current_slice]] = True
assert np.all(to_be_checked[to_be_checked_sliced])
axes_reference_to_be_checked = options.flat_mesh_axes_reference[:,
to_be_checked_sliced]
evaluation_dose = interpolate_evaluation_dose_at_distance(
options.evaluation_interpolation,
axes_reference_to_be_checked,
coordinates_at_distance_shell,
)
if options.local_gamma:
with np.errstate(divide="ignore"):
relative_dose_difference = (
evaluation_dose -
options.flat_dose_reference[to_be_checked_sliced][None, :]
) / (
options.flat_dose_reference[to_be_checked_sliced][None, :])
else:
relative_dose_difference = (
evaluation_dose -
options.flat_dose_reference[to_be_checked_sliced][None, :]
) / options.global_normalisation
min_relative_dose_difference[current_slice] = np.min(
np.abs(relative_dose_difference), axis=0)
return min_relative_dose_difference
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))
