def convolve_with_kernel_preserve_zeros(vector_field,
kernel=sobolev_kernel_1d,
print_focus_coord_info=False):
x_convolved = np.zeros_like(vector_field)
y_convolved = np.zeros_like(vector_field)
focus_coordinates = get_focus_coordinates()
zero_check = np.abs(vector_field) < 1e-6
for x in range(vector_field.shape[1]):
y_convolved[:, x, 0] = np.convolve(vector_field[:, x, 0],
kernel,
mode='same')
y_convolved[:, x, 1] = np.convolve(vector_field[:, x, 1],
kernel,
mode='same')
y_convolved[zero_check] = 0.0
for y in range(vector_field.shape[0]):
x_convolved[y, :, 0] = np.convolve(y_convolved[y, :, 0],
kernel,
mode='same')
x_convolved[y, :, 1] = np.convolve(y_convolved[y, :, 1],
kernel,
mode='same')
x_convolved[zero_check] = 0.0
np.copyto(vector_field, x_convolved)
if print_focus_coord_info:
new_gradient_at_focus = vector_field[focus_coordinates[1],
focus_coordinates[0]]
print(" H1 grad: {:s}[{:f} {:f}{:s}]".format(BOLD_GREEN,
-new_gradient_at_focus[0],
-new_gradient_at_focus[1],
RESET),
sep='',
end='')
return vector_field
def __generate_initial_focus_neighborhood_log(field_size):
focus_coordinates = get_focus_coordinates()
neighborhood_log = {}
for y in range(focus_coordinates[1] - 1, focus_coordinates[1] + 2):
for x in range(focus_coordinates[0] - 1, focus_coordinates[0] + 2):
if 0 <= x < field_size and 0 <= y < field_size:
neighborhood_log[(x, y)] = VoxelLog()
return neighborhood_log
def plot_logged_sdf_and_warp_magnitudes(self):
visualize_and_save_sdf_and_warp_magnitude_progression(
get_focus_coordinates(), self.focus_neighborhood_log,
self.out_path)
def __optimization_iteration_vectorized(self,
warped_live_field,
canonical_field,
warp_field,
band_union_only=True):
live_gradient_y, live_gradient_x = np.gradient(warped_live_field)
data_gradient_field = dt.compute_data_term_gradient_vectorized(
warped_live_field, canonical_field, live_gradient_x,
live_gradient_y)
set_zeros_for_values_outside_narrow_band_union(warped_live_field,
canonical_field,
data_gradient_field)
self.total_data_energy = \
dt.compute_data_term_energy_contribution(warped_live_field, canonical_field) * self.data_term_weight
smoothing_gradient_field = st.compute_smoothing_term_gradient_vectorized(
warp_field)
self.total_smoothing_energy = \
st.compute_smoothing_term_energy(warp_field, warped_live_field,
canonical_field) * self.smoothing_term_weight
if self.visualizer.data_component_field is not None:
np.copyto(self.visualizer.data_component_field,
data_gradient_field)
if self.visualizer.smoothing_component_field is not None:
np.copyto(self.visualizer.smoothing_component_field,
smoothing_gradient_field)
if self.visualizer.level_set_component_field is not None:
frame_info = getframeinfo(currentframe())
print(
"Warning: level set term not implemented in vectorized version, "
"passed level_set_component_field is not None, {:s} : {:d}".
format(frame_info.filename, frame_info.lineno))
self.gradient_field = self.data_term_weight * data_gradient_field + \
self.smoothing_term_weight * smoothing_gradient_field
if band_union_only:
set_zeros_for_values_outside_narrow_band_union(
warped_live_field, canonical_field, self.gradient_field)
# *** Print information at focus voxel
focus_x, focus_y = get_focus_coordinates()
focus = (focus_y, focus_x)
print("Point: ", focus_x, ",", focus_y, sep='', end='')
dt.compute_local_data_term(warped_live_field,
canonical_field,
focus_x,
focus_y,
live_gradient_x,
live_gradient_y,
method=dt.DataTermMethod.BASIC)
focus_data_gradient = data_gradient_field[focus]
print(" Data grad: ",
BOLD_GREEN,
-focus_data_gradient,
RESET,
sep='',
end='')
st.compute_local_smoothing_term_gradient(
warp_field,
focus_x,
focus_y,
method=self.smoothing_term_method,
copy_if_zero=False,
isomorphic_enforcement_factor=self.isomorphic_enforcement_factor)
focus_smoothing_gradient = smoothing_gradient_field[
focus] * self.smoothing_term_weight
print(" Smoothing grad (scaled): ",
BOLD_GREEN,
-focus_smoothing_gradient,
RESET,
sep='',
end='')
# ***
if self.sobolev_smoothing_enabled:
convolve_with_kernel_preserve_zeros(self.gradient_field,
self.sobolev_kernel, True)
np.copyto(warp_field,
-self.gradient_field * self.gradient_descent_rate)
warp_lengths = np.linalg.norm(warp_field, axis=2)
maximum_warp_length_at = np.unravel_index(np.argmax(warp_lengths),
warp_lengths.shape)
maximum_warp_length = warp_lengths[maximum_warp_length_at]
# ***
print(" Warp: ",
BOLD_GREEN,
warp_field[focus],
RESET,
" Warp length: ",
BOLD_GREEN,
np.linalg.norm(warp_field[focus]),
RESET,
sep='')
# ***
get_and_print_interpolation_data(canonical_field, warped_live_field,
warp_field, focus_x, focus_y)
u_vectors = warp_field[:, :, 0].copy()
v_vectors = warp_field[:, :, 1].copy()
out_warped_live_field, (out_u_vectors, out_v_vectors) = \
cpp_extension.resample(warped_live_field, canonical_field, u_vectors, v_vectors)
np.copyto(warped_live_field, out_warped_live_field)
# some entries might have been erased due to things in the live sdf becoming truncated
warp_field[:, :, 0] = out_u_vectors
warp_field[:, :, 1] = out_v_vectors
return maximum_warp_length, Point2d(maximum_warp_length_at[1],
maximum_warp_length_at[0])
def convolve_with_kernel(vector_field,
kernel=sobolev_kernel_1d,
print_focus_coord_info=False):
x_convolved = np.zeros_like(vector_field)
y_convolved = np.zeros_like(vector_field)
z_convolved = None
if len(vector_field.shape) == 3 and vector_field.shape[2] == 2:
focus_coordinates = get_focus_coordinates()
for x in range(vector_field.shape[1]):
y_convolved[:, x, 0] = np.convolve(vector_field[:, x, 0],
kernel,
mode='same')
y_convolved[:, x, 1] = np.convolve(vector_field[:, x, 1],
kernel,
mode='same')
for y in range(vector_field.shape[0]):
x_convolved[y, :, 0] = np.convolve(y_convolved[y, :, 0],
kernel,
mode='same')
x_convolved[y, :, 1] = np.convolve(y_convolved[y, :, 1],
kernel,
mode='same')
if print_focus_coord_info:
new_gradient_at_focus = vector_field[focus_coordinates[1],
focus_coordinates[0]]
print(" H1 grad: {:s}[{:f} {:f}{:s}]".format(
BOLD_GREEN, -new_gradient_at_focus[0],
-new_gradient_at_focus[1], RESET),
sep='',
end='')
np.copyto(vector_field, x_convolved)
elif len(vector_field.shape) == 4 and vector_field.shape[3] == 3:
z_convolved = np.zeros_like(vector_field)
for z in range(vector_field.shape[0]):
for y in range(vector_field.shape[1]):
for i_val in range(3):
x_convolved[z, y, :,
i_val] = np.convolve(vector_field[z, y, :,
i_val],
kernel,
mode='same')
for z in range(vector_field.shape[0]):
for x in range(vector_field.shape[2]):
for i_val in range(3):
y_convolved[z, :, x,
i_val] = np.convolve(x_convolved[z, :, x,
i_val],
kernel,
mode='same')
for y in range(vector_field.shape[1]):
for x in range(vector_field.shape[2]):
for i_val in range(3):
z_convolved[:, y, x,
i_val] = np.convolve(y_convolved[:, y, x,
i_val],
kernel,
mode='same')
np.copyto(vector_field, z_convolved)
else:
raise ValueError(
"Can only process tensors with 3 dimensions (where last dimension is 2) or "
"tensors with 4 dimensions (where last dimension is 3), i.e. 2D & 3D vector fields"
)
return vector_field
def mark_focus_coordinate_on_sdf_image(image, scale=8):
focus_coordinates = get_focus_coordinates()
return mark_point_on_sdf_image(
image, Point2d(focus_coordinates[0], focus_coordinates[1]), scale)
