def getRandomTransform(maxRot=10, maxScale=1.15, maxTrans=20): """ Choose a random 2D transform (scale, rotation, and translation in two directions, where scale is a single value applied in both x and y dimensions). Max rotation given in degrees (in either direction). Max translation in pixels and max scale in proportion. Return a transform object implementing it """ highlimits = [maxRot, maxScale, maxTrans, maxTrans] lowlimits = [-l for l in highlimits] lowlimits[1] = 1 / maxScale rot, scale, xtrans, ytrans = np.random.uniform(low=lowlimits, high=highlimits) scaleT = transforms.ScalingTransform(2, uniform=True) scaleT.set_params([ scale, ]) rigidT = transforms.Rigid2DTransform() rigidT.set_params([np.pi * rot / 180, xtrans, ytrans]) return transforms.CompositeTransform(2, [scaleT, rigidT])
def main(): np.random.seed(1000) if len(sys.argv) < 3: print( f'{sys.argv[0]}: Too few parameters. Give the path to two gray-scale image files.' ) print(f'Example: python {sys.argv[0]} reference_image floating_image') return False ref_im_path = sys.argv[1] flo_im_path = sys.argv[2] ref_im = Image.open(ref_im_path).convert('L') flo_im = Image.open(flo_im_path).convert('L') ref_im = np.asarray(ref_im) / 255. flo_im = np.asarray(flo_im) / 255. # Make copies of original images ref_im_orig = ref_im.copy() flo_im_orig = flo_im.copy() # Preprocess images ref_im = filters.normalize(ref_im, 0.0, None) flo_im = filters.normalize(flo_im, 0.0, None) weights1 = np.ones(ref_im.shape) mask1 = np.ones(ref_im.shape, 'bool') weights2 = np.ones(flo_im.shape) mask2 = np.ones(flo_im.shape, 'bool') # Initialize registration framework for 2d images reg = Register(2) reg.set_image_data(ref_im, flo_im, mask1, mask2, weights1, weights2) # Choose a registration model reg.set_model('alphaAMD', alpha_levels=alpha_levels, \ symmetric_measure=symmetric_measure, \ squared_measure=squared_measure) # Setup the Gaussian pyramid resolution levels reg.add_pyramid_level(4, 5.0) reg.add_pyramid_level(2, 3.0) reg.add_pyramid_level(1, 0.0) # Choose an optimizer and set optimizer-specific parameters # For GD and adam, learning-rate / Step lengths given by [[start1, end1], [start2, end2] ...] (for each pyramid level) reg.set_optimizer('adam', \ gradient_magnitude_threshold=0.01, \ iterations=param_iterations ) # reg.set_optimizer('gd', \ # step_length=np.array([1., 0.5, 0.25]), \ # end_step_length=np.array([0.4, 0.2, 0.01]), \ # gradient_magnitude_threshold=0.01, \ # iterations=param_iterations # ) # reg.set_optimizer('scipy', \ # iterations=param_iterations, \ # epsilon=0.001 \ # ) # Scale all transform parameters to approximately the same order of magnitude, based on sizes of images diag = 0.5 * (transforms.image_diagonal(ref_im, spacing) + transforms.image_diagonal(flo_im, spacing)) # Create the initial transform and add it to the registration framework # (switch between affine/rigid transforms by commenting/uncommenting) # # Affine # initial_transform = transforms.AffineTransform(2) # param_scaling = np.array([1.0/diag, 1.0/diag, 1.0/diag, 1.0/diag, 1.0, 1.0]) # reg.add_initial_transform(initial_transform, param_scaling=param_scaling) # # Rigid 2D # initial_transform = transforms.Rigid2DTransform() # param_scaling = np.array([1.0/diag, 1.0, 1.0]) # reg.add_initial_transform(initial_transform, param_scaling=param_scaling) # Composite scale + rigid param_scaling = np.array([1.0 / diag, 1.0 / diag, 1.0, 1.0]) initial_transform = transforms.CompositeTransform(2, [transforms.ScalingTransform(2, uniform=True), \ transforms.Rigid2DTransform()]) reg.add_initial_transform(initial_transform, param_scaling=param_scaling) # Set up other registration framework parameters reg.set_report_freq(param_report_freq) reg.set_sampling_fraction(param_sampling_fraction) # Create output directory directory = os.path.dirname(outdir) if not os.path.exists(directory): os.makedirs(directory) # Start the pre-processing reg.initialize(outdir) # Control the formatting of numpy np.set_printoptions(suppress=True, linewidth=200) # Start the registration reg.run() (transform, value) = reg.get_output(0) ### Warp final image c = transforms.make_image_centered_transform(transform, ref_im, flo_im, spacing, spacing) # Print out transformation parameters and status print('Starting from %s, optimizer terminated with message: %s'%(str(initial_transform.get_params()), \ reg.get_output_messages()[0])) print('Final transformation parameters: %s.' % str(transform.get_params())) # Create the output image ref_im_warped = np.zeros(ref_im.shape) mask = np.ones(flo_im_orig.shape, dtype='bool') warped_mask = np.zeros(ref_im.shape, dtype='bool') # Transform the floating image into the reference image space by applying transformation 'c' c.warp(In=flo_im_orig, Out=ref_im_warped, in_spacing=spacing, out_spacing=spacing, mode='spline', bg_value=0.0) c.warp(In=mask, Out=warped_mask, in_spacing=spacing, out_spacing=spacing, mode='spline', bg_value=0.0) # Save the registered image Image.fromarray(ref_im_warped).convert('RGB').save(outdir + 'registered.png') # Compute the absolute difference image between the reference and registered images D1 = np.abs(ref_im_orig - ref_im_warped) err = np.mean(D1[warped_mask]) print("Err: %f" % err) Image.fromarray(D1).convert('RGB').save(outdir + 'diff.png') return True
def main(): #np.random.seed(1000) if len(sys.argv) > 1: ref_im_path = sys.argv[1] else: ref_im_path = example_ref_im if len(sys.argv) > 2: flo_im_path = sys.argv[2] else: flo_im_path = example_flo_im print('Registering floating image %s with reference image %s' % (flo_im_path, ref_im_path)) print('Similarity measure %s, optimizer %s' % (param_method, param_optimizer)) ref_im = Image.open(ref_im_path).convert('L') flo_im = Image.open(flo_im_path).convert('L') ref_im = np.asarray(ref_im) flo_im = np.asarray(flo_im) # Save copies of original images ref_im_orig = ref_im.copy() flo_im_orig = flo_im.copy() # Initialize registration model for 2d images and do specific preprocessing and setup for that model if param_method.lower() == 'alphaamd': reg = models.RegisterAlphaAMD(2) reg.set_alpha_levels(alpha_levels) ref_im = filters.normalize(ref_im, 0.0, None) flo_im = filters.normalize(flo_im, 0.0, None) elif param_method.lower() == 'mi': ref_im = filters.normalize(ref_im, 0.0, None) flo_im = filters.normalize(flo_im, 0.0, None) reg = models.RegisterMI(2) else: raise NotImplementedError('Method must be one of alphaAMD, MI') reg.set_report_freq(param_report_freq) # Generic initialization steps required for every registration model weights1 = np.ones(ref_im.shape) mask1 = np.ones(ref_im.shape, 'bool') weights2 = np.ones(flo_im.shape) mask2 = np.ones(flo_im.shape, 'bool') reg.set_reference_image(ref_im) reg.set_reference_mask(mask1) reg.set_reference_weights(weights1) reg.set_floating_image(flo_im) reg.set_floating_mask(mask2) reg.set_floating_weights(weights2) # Setup the Gaussian pyramid resolution levels reg.add_pyramid_level(4, 5.0) reg.add_pyramid_level(2, 3.0) reg.add_pyramid_level(1, 0.0) # Learning-rate / Step lengths [[start1, end1], [start2, end2] ...] (for each pyramid level) step_lengths = np.array([[1., 1.], [1., 0.5], [0.5, 0.1]]) # Estimate an appropriate parameter scaling based on the sizes of the images. diag = transforms.image_diagonal( ref_im, spacing) + transforms.image_diagonal(flo_im, spacing) diag = 2.0 / diag # Create the transform and add it to the registration framework (switch between affine/rigid transforms by commenting/uncommenting) # Affine # reg.add_initial_transform(transforms.AffineTransform(2), param_scaling=np.array([diag, diag, diag, diag, 1.0, 1.0])) # Rigid 2D #reg.add_initial_transform(transforms.Rigid2DTransform(), param_scaling=np.array([diag, 1.0, 1.0])) # Uniform scale, rotate and translate t = transforms.CompositeTransform(2, [transforms.ScalingTransform(2, uniform=True), \ transforms.Rigid2DTransform()]) reg.add_initial_transform(t, param_scaling=np.array([diag, diag, 1.0, 1.0])) # Set the parameters reg.set_iterations(param_iterations) reg.set_gradient_magnitude_threshold(1e-6) reg.set_sampling_fraction(param_sampling_fraction) reg.set_step_lengths(step_lengths) reg.set_optimizer(param_optimizer) # Create output directory directory = os.path.dirname(param_outdir) if not os.path.exists(directory): os.makedirs(directory) # Start the pre-processing reg.initialize(param_outdir) # Control the formatting of numpy np.set_printoptions(suppress=True, linewidth=200) # Start the registration reg.run() (transform, value) = reg.get_output(0) ### Warp final image c = transforms.make_image_centered_transform(transform, ref_im, flo_im, spacing, spacing) # Print out transformation parameters print('Transformation parameters: %s.' % str(transform.get_params())) # Create the output image ref_im_warped = np.zeros(ref_im.shape) # Transform the floating image into the reference image space by applying transformation 'c' c.warp(In=flo_im_orig, Out=ref_im_warped, in_spacing=spacing, out_spacing=spacing, mode='spline', bg_value=0.0) # Cast back to integer values for mutual information comparison ref_im_warped = np.rint(ref_im_warped).astype('uint8') mask = np.ones(flo_im.shape) warped_mask = np.zeros(ref_im.shape) c.warp(In=mask, Out=warped_mask, in_spacing=spacing, out_spacing=spacing, mode='nearest', bg_value=0.0) value1 = mutual_info_score(ref_im[warped_mask > 0], ref_im_warped[warped_mask > 0]) print("Mutual info at estimated transform:", value1) # plt.figure() # plt.subplot(121) # plt.imshow(ref_im_warped, vmin=0, vmax=255, cmap='gray') # plt.title("Registered image") # plt.subplot(122) # plt.imshow(warped_mask, vmin=0, vmax=1, cmap='gray') # plt.show() # Save the registered image Image.fromarray(ref_im_warped).convert('RGB').save(param_outdir + 'registered.png') ### Compare with ground truth scaling_trans = transforms.ScalingTransform(2, uniform=True) scaling_trans.set_params([ 1, ]) rigid_trans = transforms.Rigid2DTransform() rigid_trans.set_params([0.35, 0.5, 0.5]) gt_transform = transforms.CompositeTransform(2, [scaling_trans, rigid_trans]) c2 = transforms.make_image_centered_transform(gt_transform, ref_im, flo_im, spacing, spacing) # Print out ground truth transformation parameters print('Ground Truth transformation parameters: %s.' % str(gt_transform.get_params())) # Create the output image warped_image = np.zeros(ref_im.shape) mask = np.ones(flo_im_orig.shape) warped_mask = np.zeros(ref_im.shape) # Transform the floating image into the reference image space by applying transformation defined above c2.warp(In=flo_im_orig, Out=warped_image, mode='spline', bg_value=0) # Apply the same transform to the mask to determine which pixels are within the original image c2.warp(In=mask, Out=warped_mask, mode='nearest', bg_value=0) # Cast back to integer values for mutual information comparison warped_image = np.rint(warped_image).astype('uint8') value2 = mutual_info_score(ref_im[warped_mask > 0], warped_image[warped_mask > 0]) print("Mutual info at ground truth:", value2) plt.figure() plt.subplot(131) plt.imshow(ref_im_warped, vmin=0, vmax=255, cmap='gray') plt.title("Registered image") plt.subplot(132) plt.imshow(warped_image, vmin=0, vmax=255, cmap='gray') plt.title("Ground truth") plt.subplot(133) plt.imshow(abs(ref_im_warped.astype(float) - warped_image.astype(float)), vmin=0, vmax=255, cmap='gray') plt.title("Difference") plt.show() # Compute the absolute difference image between the reference and registered images D1 = np.abs(ref_im_orig - ref_im_warped) err = np.mean(D1) print("Err: %f" % err) Image.fromarray(D1).convert('RGB').save(param_outdir + 'diff.png') return True
def create_surface(server=False): init_t = transforms.CompositeTransform(2, [transforms.ScalingTransform(2, uniform=True), \ transforms.Rigid2DTransform()]) # rigT = transforms.Rigid2DTransform() # rigT.set_params([0.35,0.5,0.5]) # rigT.set_params([0.,0.,0.]) # init_t = transforms.CompositeTransform(2, [transforms.ScalingTransform(2, uniform=True), rigT]) ##### Running parameters to update each time ##### modelname = 'dLDP' #Choose from ['alphaAMD', 'MI', 'MSE', 'dLDP'] # modelparams = {} modelparams = {'version': 'dLDP_48'} #dLDP versions: dLDP_8, dLDP_48, LDP # modelparams = {'alpha_levels':7, 'symmetric_measure':True, 'squared_measure':False} # modelparams = {'mutual_info_fun':'norm'} optname = 'gridsearch' #Choose from ['gd', 'adam', 'gridsearch', 'bfgs'] # optparams = {'gradient_magnitude_threshold':1e-9, 'epsilon':0.02} optparams = { 'bounds': gridBounds(init_t, 0.05, 5, 0), 'steps': [41, 41, 1, 1] } # optparams = {'gradient_magnitude_threshold':1e-6} norm = True blur = 0.0 skip = 24 limit = 1 folder = local_sr_folder ##### End running parameters ##### # for slide, roi_idx, ref_im, flo_im in getNextSRPair(folder, order=True, verbose=True, server=server, norm=norm, blur=blur): for slide, roi_idx, ref_im, flo_im in getNextMPMPair(verbose=True, server=server, norm=norm, blur=blur): # slide = 'cilia' # roi_idx = 'none' # ref_im, _ = OpenAndPreProcessImage('./test_images/reference_example.png', norm=norm, blur=blur, copyOrig=False) # flo_im, _ = OpenAndPreProcessImage('./test_images/floating_example.png', norm=norm, blur=blur, copyOrig=False) # if True: #to save re-indenting after temporarily removing above loop if skip > 0: print("Skipping %s_%s" % (slide, roi_idx)) skip -= 1 continue limit -= 1 if limit < 0: break print("Creating %s surface for sample %s, region %s" % (modelname, slide, roi_idx)) reg = Register(2) reg.set_model(modelname, **modelparams) # Choose an optimzer, apply basic parameters specified above reg.set_optimizer(optname, **optparams) reg.set_image_data(ref_im, \ flo_im, \ ref_mask=np.ones(ref_im.shape, 'bool'), \ flo_mask=np.ones(flo_im.shape, 'bool'), \ ref_weights=None, \ flo_weights=None ) reg.add_pyramid_levels(factors=[ 1, ], sigmas=[ 0.0, ]) reg.set_sampling_fraction(0.25) # #Adam, GD # step_lengths = np.array([[0.5, 0.1]]) # reg.set_step_lengths(step_lengths) # reg.add_initial_transform(init_t, param_scaling=[1 / 500., 1 / 500., 1., 1.]) reg.set_report_freq(500) # Create output directory directory = os.path.dirname("./tmp/") if not os.path.exists(directory): os.makedirs(directory) # Start the pre-processing reg.initialize("./tmp/") # Start the registration reg.run() values = np.array(reg.get_value_history(0, 0)) if True: #Show 2d surface axes = [0, 1] values.resize([optparams['steps'][a] for a in axes]) gridpts = [np.linspace(*optparams['bounds'][i], optparams['steps'][i]) \ for i in range(len(optparams['bounds']))] #Convert radians to degrees for display gridpts[1] *= 180 / np.pi #Determine what aspect is needed for a square image aspect = (gridpts[axes[1]][-1] - gridpts[axes[1]][0]) / ( gridpts[axes[0]][-1] - gridpts[axes[0]][0]) min_loc = np.unravel_index(np.argmin(values), values.shape) min_loc = [gridpts[i][min_loc[idx]] for idx, i in enumerate(axes)] plt.figure(figsize=(10, 10)) ax = plt.gca() im = ax.imshow(values, extent=[gridpts[axes[1]][0], gridpts[axes[1]][-1], \ gridpts[axes[0]][0], gridpts[axes[0]][-1]], \ origin='lower', aspect=aspect, cmap='inferno_r') plt.colorbar(im, fraction=0.046, pad=0.04) plt.title(f"{modelname} surface as scale and rotation change\n" \ +f"(translation fixed at zero, image{'' if blur else ' not'} smoothed)") # plt.title(f"{modelname} surface as translation changes\n" \ # +f"(scale 1.0, rotation 0, image{'' if blur else ' not'} smoothed)") min_loc = list(reversed(min_loc)) plt.annotate('Min=%.4f at (%.1f, %.2f)' % (np.min(values), *min_loc), xy=min_loc, xycoords='data', xytext=(0.6, 0.04), textcoords='figure fraction', arrowprops=dict(arrowstyle="->")) axisnames = [ 'Scale (%)', 'Rotation (degrees)', 'x translation (px)', 'y translation (px)' ] plt.xlabel(axisnames[axes[1]]) plt.ylabel(axisnames[axes[0]]) plt.show()
def create_dLDP_illustration(): id_trans = transforms.CompositeTransform(2, [transforms.ScalingTransform(2, uniform=True), \ transforms.Rigid2DTransform()]) skip = 24 limit = 1 norm = True blur = 3.0 modelname = 'dLDP' #Choose from ['alphaAMD', 'MI', 'MSE', 'dLDP'] modelparams = {'interpolation': 'nearest'} optname = 'gridsearch' #Choose from ['gd', 'adam', 'gridsearch', 'bfgs'] optparams = { 'bounds': gridBounds(id_trans, 0, 0, 0), 'steps': [1, 1, 1, 1] } for slide, roi_idx, ref_im, flo_im in getNextMPMPair(verbose=True, \ server=False, \ norm=norm, \ blur=blur, \ rotate=True, \ quantize=32): if skip > 0: skip -= 1 continue limit -= 1 if limit < 0: break reg = Register(2) reg.set_model(modelname, **modelparams) reg.set_optimizer(optname, **optparams) reg.set_image_data(ref_im, \ flo_im, \ ref_mask=np.ones(ref_im.shape, 'bool'), \ flo_mask=np.ones(flo_im.shape, 'bool'), \ ref_weights=None, \ flo_weights=None ) reg.add_pyramid_levels(factors=[ 1, ], sigmas=[ 0.0, ]) reg.add_initial_transform(id_trans) # Start the pre-processing reg.initialize("./tmp/") # The initialization sets up the distance measure, now we can use it dist = reg.distances[-1] shg_dLDP, shg_mask = dist.create_LDP(ref_im) tpef_dLDP, tpef_mask = dist.create_LDP(flo_im) #show what the dLDPs look like for ref image fig = plt.figure(figsize=(15, 10)) plt.subplot(2, 3, 1) plt.imshow(ref_im, cmap='gray', vmin=0, vmax=1) plt.title('a)', loc='left') plt.axis('off') #show (d)LDP images for two pairs of directions i = 0 # i=0 #0 degrees for LDP; i=1 #0, 90 for dLDP shg_dLDP_im1 = dist.dLDP_as_image( shg_dLDP[..., (8 * i):(8 * (i + 1))]) #Turn the next 8 bits into an image i = 2 # i=2 #90 degrees for LDP; i=4 #45, 135 for dLDP shg_dLDP_im2 = dist.dLDP_as_image( shg_dLDP[..., (8 * i):(8 * (i + 1))]) #Turn the next 8 bits into an image plt.subplot(2, 3, 2) plt.imshow(shg_dLDP_im1, cmap='gray', vmin=0, vmax=1) plt.title('b)', loc='left') plt.axis('off') plt.subplot(2, 3, 3) plt.imshow(shg_dLDP_im2, cmap='gray', vmin=0, vmax=1) plt.title('c)', loc='left') plt.axis('off') #same for floating image plt.subplot(2, 3, 4) plt.imshow(flo_im, cmap='gray', vmin=0, vmax=1) plt.title('d)', loc='left') plt.axis('off') #show dLDP images for two pairs of directions i = 0 # i=0 #0 degrees for LDP; i=1 #0, 90 for dLDP tpef_dLDP_im1 = dist.dLDP_as_image( tpef_dLDP[..., (8 * i):(8 * (i + 1))]) #Turn the next 8 bits into an image i = 2 # i=2 #90 degrees for LDP; i=4 #45, 135 for dLDP tpef_dLDP_im2 = dist.dLDP_as_image( tpef_dLDP[..., (8 * i):(8 * (i + 1))]) #Turn the next 8 bits into an image plt.subplot(2, 3, 5) plt.imshow(tpef_dLDP_im1, cmap='gray', vmin=0, vmax=1) plt.title('e)', loc='left') plt.axis('off') plt.subplot(2, 3, 6) plt.imshow(tpef_dLDP_im2, cmap='gray', vmin=0, vmax=1) plt.title('f)', loc='left') plt.axis('off') fig.subplots_adjust(hspace=0.1, wspace=0.05) plt.show()
def register_pairs(server=False): #TODO. Docstrings. results = [] id_trans = transforms.CompositeTransform(2, [transforms.ScalingTransform(2, uniform=True), \ transforms.Rigid2DTransform()]) ##### Running parameters to update each time ##### modelname = 'dLDP' #['alphaAMD', 'MI', 'MSE', 'dLDP'] # modelparams = {} #mse modelparams = {'version': 'dLDP_48'} #dLDP versions: dLDP_8, dLDP_48, LDP # modelparams = {'alpha_levels':7, 'symmetric_measure':True, 'squared_measure':False} # modelparams = {'mutual_info_fun':'norm'} optname = 'bfgs' #['gd', 'adam', 'gridsearch', 'bfgs'] optparams = {'gradient_magnitude_threshold': 1e-9, 'epsilon': 0.05} #bfgs # optparams = {'bounds':gridBounds(id_trans, 0.05, 5, 10), 'steps':11} #gridsearch # optparams = {'gradient_magnitude_threshold':1e-6} #adam, gd norm = True blur = 3.0 skip = 0 #5 #manual way to skip pairs that have already been processed results_file = 'PartIII_test5.10_48bit.csv' limit = 25 - skip ##### End running parameters ##### np.random.seed( 999) #For testing, make sure we get the same transforms each time rndTransforms = [ getRandomTransform(maxRot=5, maxScale=1.05, maxTrans=10) for _ in range(limit + skip + 1) ] #Reverse the list as we will pop transforms from the far end. Want these to be the same, even #if we change the limit later. rndTransforms.reverse() folder = local_sr_folder if server: folder = server_sr_folder if server: outfile = server_separate_mpm_folder + results_file else: outfile = local_separate_mpm_folder + results_file # id_trans.set_params([1.,0.2,10.,10.]) #Nelder mead doesn't work starting from zeros #OPTION: Starting from gridmax already found # grid_params = get_MI_gridmax(local_separate_mpm_folder+'PartI_test4.csv') # for slide, roi_idx, ref_im, flo_im in getNextSRPair(folder, order=True, verbose=True, server=server, norm=norm, blur=blur): # for slide, roi_idx, mpm_path, al_path in getNextPair(): for slide, roi_idx, ref_im, flo_im in getNextMPMPair(verbose=True, server=server, norm=norm, blur=blur): # Take the next random transform rndTrans = rndTransforms.pop() if skip > 0: print("Skipping %s_%s" % (slide, roi_idx)) skip -= 1 continue limit -= 1 if limit < 0: break # Open and prepare the images: if using SRs then don't normalize (or do?) # ref_im, ref_im_orig = OpenAndPreProcessImage(al_path, copyOrig=True) # flo_im, flo_im_orig = OpenAndPreProcessImage(mpm_path, copyOrig=True) #If aligning SHG + TPEF, keep a copy of the SHG (reference) image #as it was before random transform is applied # flo_im_orig = flo_im.copy() ref_im_orig = ref_im.copy() print("Random transform applied: %r" % rndTrans.get_params()) # Apply the transform to the reference image, increasing the canvas size to avoid cutting off parts ref_im = centreAndApplyTransform( ref_im, rndTrans, np.rint(np.array(ref_im.shape) * 1.5).astype('int')) # Show the images we are working with print("Aligning images for sample %s, region %s"%(slide, roi_idx) \ # + ". A transform of %r has been applied to the reference image"%str(rndTrans.get_params()) # + " from folder %s"%folder) ) if False: plt.figure(figsize=(12, 6)) plt.subplot(121) plt.imshow(ref_im, cmap='gray', vmin=0, vmax=1) plt.title("Reference image") plt.subplot(122) plt.imshow(flo_im, cmap='gray', vmin=0, vmax=1) plt.title("Floating image") plt.show() # Choose a model, set basic parameters for that model reg = Register(2) reg.set_model(modelname, **modelparams) # Choose an optimzer, set basic parameters for it reg.set_optimizer(optname, **optparams) # Since we have warped the original reference image, create a mask so that only the relevant # pixels are considered. Use the same warping function as above ref_mask = np.ones(ref_im_orig.shape, 'bool') ref_mask = centreAndApplyTransform( ref_mask, rndTrans, np.rint(np.array(ref_im_orig.shape) * 1.5).astype('int')) reg.set_image_data(ref_im, \ flo_im, \ ref_mask=ref_mask, \ flo_mask=np.ones(flo_im.shape, 'bool'), \ ref_weights=None, \ flo_weights=None ) ## Add pyramid levels if modelname.lower() == 'alphaamd': # Learning-rate / Step lengths [[start1, end1], [start2, end2] ...] (for each pyramid level) step_lengths = np.array([[1., 1.], [1., 0.5], [0.5, 0.1]]) reg.set_step_lengths(step_lengths) reg.add_pyramid_levels(factors=[4, 2, 1], sigmas=[5.0, 3.0, 0.0]) reg.set_sampling_fraction( 0.5) #very patchy with 0.1, also tried 0.25 reg.set_iterations(5000) else: # I have seen no evidence so far, that pyramid levels lead the search towards the MI maximum. reg.add_pyramid_levels(factors=[ 1, ], sigmas=[ 0.0, ]) # Try with a blurred full-resolution image first (or only) # reg.add_pyramid_levels(factors=[1,1], sigmas=[5.0,0.0]) ## Add initial transform(s), with parameter scaling if required if optname.lower() == 'gridsearch': reg.add_initial_transform(id_trans) else: #BFGS and AlphaAMD # Estimate an appropriate parameter scaling based on the sizes of the images (not used in grid search). diag = transforms.image_diagonal( ref_im) + transforms.image_diagonal(flo_im) diag = 2.0 / diag # p_scaling = np.array([diag*100, diag*100, 5.0, 5.0]) p_scaling = np.array([diag * 2.0, diag * 2.0, 1.0, 1.0]) reg.add_initial_transform(id_trans, param_scaling=p_scaling) #OPTION: in addition to the ID transform, add a bunch of random starting points add_multiple_startpts(reg, count=20, p_scaling=p_scaling) # #OPTION: Starting from gridmax already found # if not (slide, roi_idx) in grid_params: # print(f'Grid results not found for slide {slide}, region {roi_idx}') # continue # starting_params = grid_params[(slide, roi_idx)] # s_trans = transforms.ScalingTransform(2, uniform=True) # s_trans.set_params(starting_params[0]) # r_trans = transforms.Rigid2DTransform() # r_trans.set_params(starting_params[1:4]) # starting_trans = transforms.CompositeTransform(2, [s_trans, r_trans]) # reg.add_initial_transform(starting_trans, param_scaling=p_scaling) reg.set_report_freq(250) # Create output directory directory = os.path.dirname("./tmp/") if not os.path.exists(directory): os.makedirs(directory) # Start the pre-processing reg.initialize("./tmp/", norm=norm) # Start the registration reg.run(verbose=True) # Get the results and find the best one (for the case when there # was more than one starting point) out_transforms, values = reg.get_outputs() transform = out_transforms[np.argmin(values)] value = np.min(values) successFlag = reg.get_flags() if len(successFlag) == 0: successFlag = 'N/A' else: #Use the optimizer flag for the best output transform found. SuccessFlag #has one result for each pyramid level, just take the last level. successFlag = successFlag[np.argmin(values)][-1] ### Warp final image c = transforms.make_image_centered_transform(transform, ref_im, flo_im) # # Print out transformation parameters # print('Transformation parameters: %s.' % str(transform.get_params())) # Create the output image im_warped = np.zeros(ref_im.shape) # Transform the floating image into the reference image space by applying transformation 'c' c.warp(In=flo_im, Out=im_warped, mode='nearest', bg_value=0.0) # Show the images we ended up with if False: print("Aligned images for sample %s, region %s" % (slide, roi_idx)) plt.figure(figsize=(12, 6)) plt.subplot(121) plt.imshow(ref_im, cmap='gray', vmin=0, vmax=1) plt.title("Reference image") plt.subplot(122) plt.imshow(im_warped, cmap='gray', vmin=0, vmax=1) plt.title("Floating image") plt.show() centred_gt_trans = transforms.make_image_centered_transform(rndTrans, \ ref_im, flo_im) gtVal = reg.get_value_at(rndTrans) err = get_transf_error(c, centred_gt_trans, flo_im.shape) print( "Estimated transform:\t [", ','.join(['%.4f'] * len(c.get_params())) % tuple(c.get_params()) + "] with value %.4f" % (value)) print( "True transform:\t\t [", ','.join(['%.4f'] * len(rndTrans.get_params())) % tuple(rndTrans.get_params()) + "] with value %.4f" % (gtVal)) print("Average corner error: %5f" % (err / 4)) print("Value difference: %.5f" % (gtVal - value)) # print("Improvement over gridmax: %.5f"%(-value - float(starting_params[-1]))) resultLine = (slide, roi_idx, *rndTrans.get_params(), \ gtVal, \ *c.get_params(), \ value, \ err, successFlag, \ time.strftime('%Y-%m-%d %H:%M:%S')) results.append(resultLine) with open(outfile, 'a') as f: writer = csv.writer(f, delimiter=',') writer.writerow(resultLine)