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)