def initialize(self, pyramid_images_output_path=None):
if len(self.pyramid_factors) == 0:
self.add_pyramid_level(1, 0.0)
if len(self.initial_transforms) == 0:
self.add_initial_transform(AffineTransform(self.dim))
ch = len(self.ref_im)
# print(ch)
# require same number of channels
assert (ch == len(self.flo_im))
ref_input = self.ref_im
flo_input = self.flo_im
if self.channel_mode == 'decompose_pre':
lev = None
#lev = self.alpha_levels
ref_input = filters.fidt(ref_input, lev) #self.alpha_levels)
flo_input = filters.fidt(flo_input, lev) #self.alpha_levels)
ch = len(ref_input)
### Preprocessing
pyramid_levels = len(self.pyramid_factors)
percentile = 0.01
for i in range(pyramid_levels):
factor = self.pyramid_factors[i]
ref_mask_resampled = filters.downsample(self.ref_mask, factor)
flo_mask_resampled = filters.downsample(self.flo_mask, factor)
ref_resampled = []
flo_resampled = []
for k in range(ch):
ref_k = filters.downsample(
filters.gaussian_filter(ref_input[k],
self.pyramid_sigmas[i]), factor)
flo_k = filters.downsample(
filters.gaussian_filter(flo_input[k],
self.pyramid_sigmas[i]), factor)
#if self.channel_mode == 'sum':
#ref_k = filters.normalize(ref_k, percentile, ref_mask_resampled)
#flo_k = filters.normalize(flo_k, percentile, flo_mask_resampled)
ref_resampled.append(ref_k)
flo_resampled.append(flo_k)
if self.channel_mode == 'sum' or self.channel_mode == 'decompose_pre':
pass
elif self.channel_mode == 'decompose':
ref_resampled = filters.fidt(ref_resampled, self.alpha_levels)
flo_resampled = filters.fidt(flo_resampled, self.alpha_levels)
for k in range(len(ref_resampled)):
ref_resampled[k] = filters.normalize(
ref_resampled[k], percentile, ref_mask_resampled)
flo_resampled[k] = filters.normalize(
flo_resampled[k], percentile, flo_mask_resampled)
#if pyramid_images_output_path is not None and ref_resampled[0].ndim == 2:
# scipy.misc.imsave('%sref_resampled_%d.png' % (pyramid_images_output_path, i+1), ref_resampled)
# scipy.misc.imsave('%sflo_resampled_%d.png' % (pyramid_images_output_path, i+1), flo_resampled)
if self.ref_weights is None:
ref_weights = np.zeros(ref_resampled[0].shape)
ref_weights[ref_mask_resampled] = 1.0
else:
ref_weights = filters.downsample(self.ref_weights, factor)
if self.flo_weights is None:
flo_weights = np.zeros(flo_resampled[0].shape)
flo_weights[flo_mask_resampled] = 1.0
else:
flo_weights = filters.downsample(self.flo_weights, factor)
ref_diag = np.sqrt(
np.square(np.array(ref_resampled[0].shape) *
self.ref_spacing).sum())
flo_diag = np.sqrt(
np.square(np.array(flo_resampled[0].shape) *
self.flo_spacing).sum())
dists = []
for k in range(len(ref_resampled)):
q_ref = QuantizedImage(ref_resampled[k],
self.alpha_levels,
ref_weights,
self.ref_spacing * factor,
remove_zero_weight_pnts=True)
q_flo = QuantizedImage(flo_resampled[k],
self.alpha_levels,
flo_weights,
self.flo_spacing * factor,
remove_zero_weight_pnts=True)
if self.squared_measure:
dt_fun = alpha_amd.edt_sq
else:
dt_fun = None
tf_ref = alpha_amd.AlphaAMD(q_ref,
self.alpha_levels,
ref_diag,
self.ref_spacing * factor,
ref_mask_resampled,
ref_mask_resampled,
interpolator_mode='linear',
dt_fun=dt_fun,
mask_out_edges=True)
tf_flo = alpha_amd.AlphaAMD(q_flo,
self.alpha_levels,
flo_diag,
self.flo_spacing * factor,
flo_mask_resampled,
flo_mask_resampled,
interpolator_mode='linear',
dt_fun=dt_fun,
mask_out_edges=True)
symmetric_measure = True
squared_measure = False #self.squared_measure
sym_dist = symmetric_amd_distance.SymmetricAMDDistance(
symmetric_measure=symmetric_measure,
squared_measure=squared_measure)
sym_dist.set_ref_image_source(q_ref)
sym_dist.set_ref_image_target(tf_ref)
sym_dist.set_flo_image_source(q_flo)
sym_dist.set_flo_image_target(tf_flo)
sym_dist.set_sampling_fraction(self.sampling_fraction)
sym_dist.initialize()
dists.append(sym_dist)
self.distances.append(dists)
def initialize(self, pyramid_images_output_path=None):
if len(self.pyramid_factors) == 0:
self.add_pyramid_level(1, 0.0)
if len(self.initial_transforms) == 0:
self.add_initial_transform(AffineTransform(self.dim))
### Preprocessing
pyramid_levels = len(self.pyramid_factors)
for i in range(pyramid_levels):
factor = self.pyramid_factors[i]
ref_resampled = filters.downsample(
filters.gaussian_filter(self.ref_im, self.pyramid_sigmas[i]),
factor)
flo_resampled = filters.downsample(
filters.gaussian_filter(self.flo_im, self.pyramid_sigmas[i]),
factor)
ref_mask_resampled = filters.downsample(self.ref_mask, factor)
flo_mask_resampled = filters.downsample(self.flo_mask, factor)
ref_resampled = filters.normalize(ref_resampled, 0.0,
ref_mask_resampled)
flo_resampled = filters.normalize(flo_resampled, 0.0,
flo_mask_resampled)
if pyramid_images_output_path is not None and ref_resampled.ndim == 2:
scipy.misc.imsave(
'%sref_resampled_%d.png' %
(pyramid_images_output_path, i + 1), ref_resampled)
scipy.misc.imsave(
'%sflo_resampled_%d.png' %
(pyramid_images_output_path, i + 1), flo_resampled)
if self.ref_weights is None:
ref_weights = np.zeros(ref_resampled.shape)
ref_weights[ref_mask_resampled] = 1.0
else:
ref_weights = filters.downsample(self.ref_weights, factor)
if self.flo_weights is None:
flo_weights = np.zeros(flo_resampled.shape)
flo_weights[flo_mask_resampled] = 1.0
else:
flo_weights = filters.downsample(self.flo_weights, factor)
ref_diag = np.sqrt(
np.square(np.array(ref_resampled.shape) *
self.ref_spacing).sum())
flo_diag = np.sqrt(
np.square(np.array(flo_resampled.shape) *
self.flo_spacing).sum())
q_ref = QuantizedImage(ref_resampled,
self.alpha_levels,
ref_weights,
self.ref_spacing * factor,
remove_zero_weight_pnts=True)
q_flo = QuantizedImage(flo_resampled,
self.alpha_levels,
flo_weights,
self.flo_spacing * factor,
remove_zero_weight_pnts=True)
tf_ref = alpha_amd.AlphaAMD(q_ref,
self.alpha_levels,
ref_diag,
self.ref_spacing * factor,
ref_mask_resampled,
ref_mask_resampled,
interpolator_mode='linear',
dt_fun=None,
mask_out_edges=True)
tf_flo = alpha_amd.AlphaAMD(q_flo,
self.alpha_levels,
flo_diag,
self.flo_spacing * factor,
flo_mask_resampled,
flo_mask_resampled,
interpolator_mode='linear',
dt_fun=None,
mask_out_edges=True)
symmetric_measure = True
squared_measure = False
sym_dist = symmetric_amd_distance.SymmetricAMDDistance(
symmetric_measure=symmetric_measure,
squared_measure=squared_measure)
sym_dist.set_ref_image_source(q_ref)
sym_dist.set_ref_image_target(tf_ref)
sym_dist.set_flo_image_source(q_flo)
sym_dist.set_flo_image_target(tf_flo)
sym_dist.set_sampling_fraction(self.sampling_fraction)
sym_dist.initialize()
self.distances.append(sym_dist)
def initialize(self, pyramid_images_output_path=None, norm=True):
"""Initialize the registration framework: must be called before run().
Prepare pyramid scheme by creating and saving downsampled versions of the images
for each pyramid level. Set up a distance measure (separate instance for each pyramid
level, with the corresponding version of the images).
Args:
pyramid_images_output_path: slash-terminated string specifying folder in which to
save the downsampled images. Default None. If None, images are not saved. Only
applicable for 2D images
Other running parameters are set in __init__()
"""
if len(self.pyramid_factors) == 0:
self.add_pyramid_level(1, 0.0)
if len(self.initial_transforms) == 0:
self.add_initial_transform(transforms.AffineTransform(self.dim))
# while len(self.opt_opts['step_length']) < len(self.pyramid_factors):
# self.opt_opts['step_length'] = np.concatenate((self.opt_opts['step_length'], np.array([[0,1.0]])))
### Preprocessing
pyramid_levels = len(self.pyramid_factors)
for i in range(pyramid_levels):
factor = self.pyramid_factors[i]
ref_resampled = filters.downsample(
filters.gaussian_filter(self.ref_im, self.pyramid_sigmas[i]),
factor)
flo_resampled = filters.downsample(
filters.gaussian_filter(self.flo_im, self.pyramid_sigmas[i]),
factor)
ref_mask_resampled = filters.downsample(self.ref_mask, factor)
flo_mask_resampled = filters.downsample(self.flo_mask, factor)
if norm:
ref_resampled = filters.normalize(ref_resampled, 0.0,
ref_mask_resampled)
flo_resampled = filters.normalize(flo_resampled, 0.0,
flo_mask_resampled)
if pyramid_images_output_path is not None and ref_resampled.ndim == 2:
Image.fromarray(ref_resampled).convert(
'RGB').save(pyramid_images_output_path +
'ref_resampled_%d.png' % (i + 1))
Image.fromarray(flo_resampled).convert(
'RGB').save(pyramid_images_output_path +
'flo_resampled_%d.png' % (i + 1))
if self.ref_weights is None:
ref_weights = np.zeros(ref_resampled.shape)
ref_weights[ref_mask_resampled] = 1.0
else:
ref_weights = filters.downsample(self.ref_weights, factor)
if self.flo_weights is None:
flo_weights = np.zeros(flo_resampled.shape)
flo_weights[flo_mask_resampled] = 1.0
else:
flo_weights = filters.downsample(self.flo_weights, factor)
# #add default step length in case it wasn't specified,
# #TODO can't the optimizer do this?
# self.optimizer_opts['step_length'] = self.optimizer_opts.get('step_length',np.array([[0.1]*pyramid_levels]))
# #DEBUG
# if(False):
# #Display each image with its mask to check all is ok
# plt.subplot(121)
# plt.imshow(np.hstack((ref_resampled, ref_mask_resampled)), cmap='gray')
# plt.subplot(122)
# plt.imshow(np.hstack((flo_resampled, flo_mask_resampled)), cmap='gray')
# plt.show()
# #END DEBUG
dist_measure = self._make_dist_measure(ref_resampled, ref_mask_resampled, ref_weights, \
flo_resampled, flo_mask_resampled, flo_weights, factor)
self.distances.append(dist_measure)