def create_transformed_mesh(width_data, length_data, factor_data):
"""Return factor data meshgrid."""
x = np.arange(
np.floor(np.min(width_data)) - 1,
np.ceil(np.max(width_data)) + 1, 0.1)
y = np.arange(
np.floor(np.min(length_data)) - 1,
np.ceil(np.max(length_data)) + 1, 0.1)
xx, yy = np.meshgrid(x, y)
zz = spline_model_with_deformability(
xx,
convert2_ratio_perim_area(xx, yy),
width_data,
convert2_ratio_perim_area(width_data, length_data),
factor_data,
)
zz[xx > yy] = np.nan
no_data_x = np.all(np.isnan(zz), axis=0)
no_data_y = np.all(np.isnan(zz), axis=1)
x = x[np.invert(no_data_x)]
y = y[np.invert(no_data_y)]
zz = zz[np.invert(no_data_y), :]
zz = zz[:, np.invert(no_data_x)]
return x, y, zz
def apply_negative(column):
result = np.ones_like(column).astype(np.float64) * np.nan
negative_values = column.values > 2**15
result[negative_values] = column[negative_values] - 2**16
result[np.invert(negative_values)] = column[np.invert(negative_values)]
if np.any(np.isnan(result)):
raise Exception("Not all column values were converted")
return result
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 define_rotation_field_points_at_origin(edge_lengths, penumbra):
x_half_range = edge_lengths[0] / 2 + penumbra / 2
y_half_range = edge_lengths[1] / 2 + penumbra / 2
num_x = np.ceil(x_half_range * 2 * 8) + 1
num_y = np.ceil(y_half_range * 2 * 8) + 1
x = np.linspace(-x_half_range, x_half_range, int(num_x))
y = np.linspace(-y_half_range, y_half_range, int(num_y))
xx, yy = np.meshgrid(x, y)
xx_flat = np.ravel(xx)
yy_flat = np.ravel(yy)
inside = np.logical_and((np.abs(xx_flat) < x_half_range),
(np.abs(yy_flat) < y_half_range))
xx_flat = xx_flat[np.invert(inside)]
yy_flat = yy_flat[np.invert(inside)]
return xx_flat, yy_flat
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 unknown_tags_in_dicom_dataset(ds):
"""Return all non-private tags from a DICOM dataset that do not
exist in the PyMedPhys copy of the DICOM dictionary.
"""
non_private_tags_in_dataset = np.array(
non_private_tags_in_dicom_dataset(ds))
are_non_private_tags_in_dict_baseline = []
for tag in non_private_tags_in_dataset:
try:
get_baseline_dict_entry(tag)
are_non_private_tags_in_dict_baseline.append(True)
except NotInBaselineError:
are_non_private_tags_in_dict_baseline.append(False)
unknown_tags = list(non_private_tags_in_dataset[np.invert(
np.array(are_non_private_tags_in_dict_baseline, dtype=bool))])
return unknown_tags
def find_relevant_control_points(mu):
"""Returns that control points that had an MU difference either side.
"""
mu_diff = np.diff(mu)
no_change = mu_diff == 0
try:
start = no_change[0]
end = no_change[-1]
except IndexError:
all_true = np.empty_like(mu).astype(bool)
all_true.fill(True)
return all_true
no_change_before = no_change[0:-1]
no_change_after = no_change[1::]
no_change_before_and_after = no_change_before & no_change_after
irrelevant_control_point = np.hstack(
[start, no_change_before_and_after, end])
relevant_control_points = np.invert(irrelevant_control_point)
return relevant_control_points
def calculate_pass_rate(gamma_array):
valid_gamma = gamma_array[np.invert(np.isnan(gamma_array))]
percent_pass = 100 * np.sum(valid_gamma < 1) / len(valid_gamma)
return percent_pass