def test_initial_transform_computation_1(self): # Create stack of slice with only a dot in the middle shape_xy = 15 shape_z = 15 # Original stack nda_3D = np.zeros((shape_z, shape_xy, shape_xy)) nda_3D[:, 0, 0] = 1 stack_sitk = sitk.GetImageFromArray(nda_3D) stack = st.Stack.from_sitk_image(stack_sitk, "stack") # Create 'motion corrupted stack', i.e. point moves diagonally with # step one nda_3D_corruped = np.zeros_like(nda_3D) for i in range(0, shape_z): nda_3D_corruped[i, i, i] = 1 stack_corrupted_sitk = sitk.GetImageFromArray(nda_3D_corruped) stack_corrupted = st.Stack.from_sitk_image(stack_corrupted_sitk, "stack_corrupted") # stack_corrupted.show_slices() # sitkh.show_stacks([stack, stack_corrupted]) # Ground truth-parameter: zero angle but translation = (1, 1) from one # slice to the next parameters = np.ones((shape_z, 3)) parameters[:, 0] = 0 for i in range(0, shape_z): parameters[i, :] *= i # 1) Get initial transform in case no reference is given inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted) inplane_registration.set_transform_initializer_type("moments") # inplane_registration.set_transform_initializer_type("identity") inplane_registration._run_registration_pipeline_initialization() parameters_est = inplane_registration.get_parameters() nda_diff = parameters - parameters_est self.assertEqual( np.round(np.linalg.norm(nda_diff), decimals=self.accuracy), 0) # 2) Get initial transform in case reference is given inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, stack) inplane_registration.set_transform_initializer_type("moments") # inplane_registration.set_image_transform_reference_fit_term("gradient_magnitude") # inplane_registration.set_transform_initializer_type("identity") inplane_registration._run_registration_pipeline_initialization() inplane_registration._apply_motion_correction() # stack_corrected = inplane_registration.get_corrected_stack() # sitkh.show_stacks([stack, stack_corrupted, stack_corrected.get_resampled_stack_from_slices(interpolator="Linear")]) parameters_est = inplane_registration.get_parameters() nda_diff = parameters - parameters_est # print(nda_diff) # print(parameters) self.assertEqual( np.round(np.linalg.norm(nda_diff), decimals=self.accuracy), 0)
def test_parameter_normalization(self): use_verbose = 0 filename_stack = "FetalBrain_reconstruction_3stacks_myAlg" filename_stack_corrupted = "FetalBrain_reconstruction_3stacks_myAlg_corrupted_inplane" stack_sitk = sitk.ReadImage(self.dir_test_data + filename_stack + ".nii.gz") stack_corrupted_sitk = sitk.ReadImage(self.dir_test_data + filename_stack_corrupted + ".nii.gz") stack_corrupted = st.Stack.from_sitk_image(stack_corrupted_sitk, "stack_corrupted") stack = st.Stack.from_sitk_image( sitk.Resample(stack_sitk, stack_corrupted.sitk), "stack") # sitkh.show_stacks([stack, stack_corrupted]) inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, stack) inplane_registration.set_transform_initializer_type("moments") inplane_registration.set_intensity_correction_type_slice_neighbour_fit( "affine") inplane_registration.set_transform_type("rigid") inplane_registration._run_registration_pipeline_initialization() parameters = inplane_registration.get_parameters() # Normalization routine parameters_tmp = np.array(parameters) parameter_normalization = pn.ParameterNormalization(parameters_tmp) parameter_normalization.compute_normalization_coefficients() coefficients = parameter_normalization.get_normalization_coefficients() # Check correct normalization parameters_tmp = parameter_normalization.normalize_parameters( parameters_tmp) if use_verbose: print("Normalization:") for i in range(0, parameters_tmp.shape[1]): mean = np.mean(parameters_tmp[:, i]) std = np.std(parameters_tmp[:, i]) if use_verbose: print("\tmean = %.4f" % (mean)) print("\tstd = %.4f" % (std)) # Check mean self.assertEqual(np.round(abs(mean), decimals=self.accuracy), 0) # Check standard deviation if abs(std) > 1e-8: self.assertEqual( np.round(abs(std - 1), decimals=self.accuracy), 0) # Check correct normalization parameters_tmp = parameter_normalization.denormalize_parameters( parameters_tmp) if use_verbose: print("\nDenormalization:") for i in range(0, parameters_tmp.shape[1]): mean = np.mean(parameters_tmp[:, i]) std = np.std(parameters_tmp[:, i]) if use_verbose: print("\tmean = %.4f" % (mean)) print("\tstd = %.4f" % (std)) # Check mean self.assertEqual( np.round(abs(mean - coefficients[0, i]), decimals=self.accuracy), 0) # Check standard deviation if abs(std) > 1e-8: self.assertEqual( np.round(abs(std - coefficients[1, i]), decimals=self.accuracy), 0) # Check parameter values self.assertEqual( np.round(np.linalg.norm(parameters_tmp - parameters), decimals=self.accuracy), 0)
def test_inplane_similarity_alignment_to_reference(self): filename_stack = "fetal_brain_0" # filename_stack = "3D_SheppLoganPhantom_64" stack = st.Stack.from_filename( os.path.join(self.dir_test_data, filename_stack + ".nii.gz"), os.path.join(self.dir_test_data, filename_stack + "_mask.nii.gz")) # stack.show(1) nda = sitk.GetArrayFromImage(stack.sitk) nda_mask = sitk.GetArrayFromImage(stack.sitk_mask) i = 5 nda_slice = np.array(nda[i, :, :]) nda_mask_slice = np.array(nda_mask[i, :, :]) for i in range(0, nda.shape[0]): nda[i, :, :] = nda_slice nda_mask[i, :, :] = nda_mask_slice stack_sitk = sitk.GetImageFromArray(nda) stack_sitk_mask = sitk.GetImageFromArray(nda_mask) stack_sitk.CopyInformation(stack.sitk) stack_sitk_mask.CopyInformation(stack.sitk_mask) stack = st.Stack.from_sitk_image(stack_sitk, stack.get_filename(), stack_sitk_mask) # Create in-plane motion corruption scale = 1.2 angle_z = 0.05 center_2D = (0, 0) # translation_2D = np.array([0,0]) translation_2D = np.array([1, -1]) intensity_scale = 10 intensity_bias = 50 # Get corrupted stack and corresponding motions stack_corrupted, motion_sitk, motion_2_sitk = get_inplane_corrupted_stack( stack, angle_z, center_2D, translation_2D, scale=scale, intensity_scale=intensity_scale, intensity_bias=intensity_bias, debug=0) # stack_corrupted.show(1) # stack.show(1) # Perform in-plane rigid registrations inplane_registration = inplanereg.IntraStackRegistration( stack=stack_corrupted, reference=stack) # inplane_registration = inplanereg.IntraStackRegistration(stack_corrupted) inplane_registration.set_transform_initializer_type("geometry") # inplane_registration.set_transform_initializer_type("identity") inplane_registration.set_intensity_correction_initializer_type( "affine") inplane_registration.set_transform_type("similarity") inplane_registration.set_interpolator("Linear") inplane_registration.set_optimizer_loss("linear") # inplane_registration.use_reference_mask(True) inplane_registration.use_stack_mask(True) inplane_registration.use_parameter_normalization(True) inplane_registration.set_prior_scale(1 / scale) inplane_registration.set_prior_intensity_coefficients( (intensity_scale, intensity_bias)) inplane_registration.set_intensity_correction_type_slice_neighbour_fit( "affine") inplane_registration.set_intensity_correction_type_reference_fit( "affine") inplane_registration.use_verbose(True) inplane_registration.set_alpha_reference(1) inplane_registration.set_alpha_neighbour(0) inplane_registration.set_alpha_parameter(1e10) inplane_registration.set_optimizer_iter_max(20) inplane_registration.use_verbose(True) inplane_registration.run() inplane_registration.print_statistics() # inplane_registration._run_registration_pipeline_initialization() # inplane_registration._apply_motion_correction() stack_registered = inplane_registration.get_corrected_stack() parameters = inplane_registration.get_parameters() sitkh.show_sitk_image([ stack.sitk, stack_corrupted.get_resampled_stack_from_slices( interpolator="Linear", resampling_grid=stack.sitk).sitk, stack_registered.get_resampled_stack_from_slices( interpolator="Linear", resampling_grid=stack.sitk).sitk ], label=["original", "corrupted", "recovered"]) # self.assertEqual(np.round( # np.linalg.norm(nda_diff) # , decimals = self.accuracy), 0) # 2) Test slice transforms slice_transforms_sitk = inplane_registration.get_slice_transforms_sitk( ) stack_tmp = st.Stack.from_stack(stack_corrupted) stack_tmp.update_motion_correction_of_slices(slice_transforms_sitk) stack_diff_sitk = stack_tmp.get_resampled_stack_from_slices( resampling_grid=stack.sitk ).sitk - stack_registered.get_resampled_stack_from_slices( resampling_grid=stack.sitk).sitk stack_diff_nda = sitk.GetArrayFromImage(stack_diff_sitk) self.assertEqual(np.round(np.linalg.norm(stack_diff_nda), decimals=8), 0)
def test_inplane_rigid_alignment_to_reference_with_intensity_correction_affine( self): filename_stack = "fetal_brain_0" filename_recon = "FetalBrain_reconstruction_3stacks_myAlg" stack_sitk = sitk.ReadImage(self.dir_test_data + filename_stack + ".nii.gz") recon_sitk = sitk.ReadImage(self.dir_test_data + filename_recon + ".nii.gz") recon_resampled_sitk = sitk.Resample(recon_sitk, stack_sitk) stack = st.Stack.from_sitk_image(recon_resampled_sitk, "original") # Create in-plane motion corruption angle_z = 0.01 center_2D = (0, 0) translation_2D = np.array([1, 0]) intensity_scale = 5 intensity_bias = 5 # Get corrupted stack and corresponding motions stack_corrupted, motion_sitk, motion_2_sitk = get_inplane_corrupted_stack( stack, angle_z, center_2D, translation_2D, intensity_scale=intensity_scale, intensity_bias=intensity_bias) # Perform in-plane rigid registration inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, stack) # inplane_registration = inplanereg.IntraStackRegistration(stack_corrupted) inplane_registration.set_transform_type("rigid") inplane_registration.set_transform_initializer_type("identity") inplane_registration.set_optimizer_loss("linear") inplane_registration.set_intensity_correction_initializer_type( "affine") inplane_registration.set_intensity_correction_type_slice_neighbour_fit( "affine") inplane_registration.use_parameter_normalization(True) inplane_registration.use_verbose(True) inplane_registration.use_stack_mask(True) inplane_registration.set_prior_intensity_coefficients( (intensity_scale - 0.4, intensity_bias + 0.7)) inplane_registration.set_alpha_reference(1) inplane_registration.set_alpha_neighbour(1) inplane_registration.set_alpha_parameter(1e3) inplane_registration.set_optimizer_iter_max(15) inplane_registration.use_verbose(True) inplane_registration.run() inplane_registration.print_statistics() stack_registered = inplane_registration.get_corrected_stack() parameters = inplane_registration.get_parameters() sitkh.show_stacks([ stack, stack_corrupted, stack_registered.get_resampled_stack_from_slices( resampling_grid=None, interpolator="Linear") ]) self.assertEqual( np.round( np.linalg.norm(parameters[:, -2:] - np.array([intensity_scale, intensity_bias])), decimals=0), 0) # 2) Test slice transforms slice_transforms_sitk = inplane_registration.get_slice_transforms_sitk( ) stack_tmp = st.Stack.from_stack(stack_corrupted) stack_tmp.update_motion_correction_of_slices(slice_transforms_sitk) stack_diff_sitk = stack_tmp.get_resampled_stack_from_slices( resampling_grid=stack.sitk ).sitk - stack_registered.get_resampled_stack_from_slices( resampling_grid=stack.sitk).sitk stack_diff_nda = sitk.GetArrayFromImage(stack_diff_sitk) self.assertEqual(np.round(np.linalg.norm(stack_diff_nda), decimals=8), 0)
def test_inplane_rigid_alignment_to_reference(self): filename_stack = "fetal_brain_0" # filename_recon = "FetalBrain_reconstruction_3stacks_myAlg" # stack_sitk = sitk.ReadImage(self.dir_test_data + filename_stack + ".nii.gz") # recon_sitk = sitk.ReadImage(self.dir_test_data + filename_recon + ".nii.gz") # recon_resampled_sitk = sitk.Resample(recon_sitk, stack_sitk) # stack = st.Stack.from_sitk_image(recon_resampled_sitk, "original") stack = st.Stack.from_filename( os.path.join(self.dir_test_data, filename_stack + ".nii.gz"), os.path.join(self.dir_test_data, filename_stack + "_mask.nii.gz")) # Create in-plane motion corruption angle_z = 0.1 center_2D = (0, 0) translation_2D = np.array([1, -2]) # Get corrupted stack and corresponding motions stack_corrupted, motion_sitk, motion_2_sitk = get_inplane_corrupted_stack( stack, angle_z, center_2D, translation_2D) # stack.show(1) # stack_corrupted.show(1) # Perform in-plane rigid registration inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, stack) # inplane_registration = inplanereg.IntraStackRegistration(stack_corrupted) inplane_registration.set_transform_initializer_type("moments") inplane_registration.set_optimizer_iter_max(10) inplane_registration.set_alpha_neighbour(0) inplane_registration.set_alpha_parameter(0) inplane_registration.use_stack_mask(1) inplane_registration.use_reference_mask(0) inplane_registration.set_optimizer_loss("linear") # inplane_registration.set_optimizer_method("trf") # inplane_registration._run_registration_pipeline_initialization() # inplane_registration._apply_motion_correction() # inplane_registration.use_verbose(True) inplane_registration.run() inplane_registration.print_statistics() stack_registered = inplane_registration.get_corrected_stack() parameters = inplane_registration.get_parameters() sitkh.show_stacks([ stack, stack_corrupted, stack_registered.get_resampled_stack_from_slices( interpolator="Linear", resampling_grid=stack.sitk) ]) print(parameters) # self.assertEqual(np.round( # np.linalg.norm(nda_diff) # , decimals = self.accuracy), 0) # 2) Test slice transforms slice_transforms_sitk = inplane_registration.get_slice_transforms_sitk( ) stack_tmp = st.Stack.from_stack(stack_corrupted) stack_tmp.update_motion_correction_of_slices(slice_transforms_sitk) stack_diff_sitk = stack_tmp.get_resampled_stack_from_slices( resampling_grid=stack.sitk ).sitk - stack_registered.get_resampled_stack_from_slices( resampling_grid=stack.sitk).sitk stack_diff_nda = sitk.GetArrayFromImage(stack_diff_sitk) self.assertEqual(np.round(np.linalg.norm(stack_diff_nda), decimals=8), 0)
def test_initial_intensity_coefficient_computation(self): # Create stack shape_z = 15 nda_2D = imread(self.dir_test_data + "2D_Lena_256.png", flatten=True) nda_3D = np.tile(nda_2D, (shape_z, 1, 1)).astype('double') stack_sitk = sitk.GetImageFromArray(nda_3D) stack = st.Stack.from_sitk_image(stack_sitk, "Lena") # 1) Create linearly corrupted intensity stack nda_3D_corruped = np.zeros_like(nda_3D) for i in range(0, shape_z): nda_3D_corruped[i, :, :] = nda_3D[i, :, :] / (i + 1.) stack_corrupted_sitk = sitk.GetImageFromArray(nda_3D_corruped) stack_corrupted = st.Stack.from_sitk_image(stack_corrupted_sitk, "stack_corrupted") # stack_corrupted.show_slices() # sitkh.show_stacks([stack, stack_corrupted]) # Ground truth-parameter: zero angle but translation = (1, 1) from one # slice to the next parameters = np.zeros((shape_z, 4)) parameters[:, 0] = 0 for i in range(0, shape_z): parameters[i, 3:] = 1 * (i + 1.) # intensity # Get initial transform in case no reference is given inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, stack) # inplane_registration.set_transform_initializer_type("moments") inplane_registration.set_intensity_correction_type_slice_neighbour_fit( "linear") inplane_registration.set_intensity_correction_initializer_type( "linear") inplane_registration._run_registration_pipeline_initialization() parameters_est = inplane_registration.get_parameters() nda_diff = parameters - parameters_est self.assertEqual( np.round(np.linalg.norm(nda_diff), decimals=self.accuracy), 0) # 2) Create affinely corrupted intensity stack # HINT: In case of individual slice correction is active!! nda_3D_corruped = np.zeros_like(nda_3D) for i in range(0, shape_z): nda_3D_corruped[i, :, :] = (nda_3D[i, :, :] - 10 * i) / (i + 1.) stack_corrupted_sitk = sitk.GetImageFromArray(nda_3D_corruped) stack_corrupted = st.Stack.from_sitk_image(stack_corrupted_sitk, "stack_corrupted") # stack_corrupted.show_slices() # sitkh.show_stacks([stack, stack_corrupted]) # Ground truth-parameter: zero angle but translation = (1, 1) from one # slice to the next parameters = np.zeros((shape_z, 5)) parameters[:, 0] = 0 for i in range(0, shape_z): parameters[i, 3:] = (i + 1, 10 * i) # intensity # Get initial transform in case no reference is given inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, stack) # inplane_registration.set_transform_initializer_type("moments") inplane_registration.set_intensity_correction_type_slice_neighbour_fit( "affine") inplane_registration.set_intensity_correction_initializer_type( "affine") inplane_registration._run_registration_pipeline_initialization() parameters_est = inplane_registration.get_parameters() nda_diff = parameters - parameters_est self.assertEqual( np.round(np.linalg.norm(nda_diff), decimals=self.accuracy), 0)
def test_initial_transform_computation_3(self): # Create stack of slice with a pyramid in the middle shape_xy = 250 shape_z = 15 intensity_mask = 10 length = 50 nda_2D = ph.read_image( os.path.join(DIR_TEST, "2D_Pyramid_Midpoint_" + str(length) + ".png")) # Original stack nda_3D = np.zeros((shape_z, shape_xy, shape_xy)) i0 = (shape_xy - length) / 2 for i in range(0, shape_z): nda_3D[i, i0:-i0, i0:-i0] = nda_2D nda_3D_mask = np.array(nda_3D).astype(np.uint8) nda_3D_mask[np.where(nda_3D_mask <= intensity_mask)] = 0 nda_3D_mask[np.where(nda_3D_mask > intensity_mask)] = 1 # Add additional weight s.t. initialization without mask fails for i in range(0, shape_z): nda_3D[i, -i0:, -i0:] = 10 stack_sitk = sitk.GetImageFromArray(nda_3D) stack_sitk_mask = sitk.GetImageFromArray(nda_3D_mask) stack = st.Stack.from_sitk_image(stack_sitk, "stack", stack_sitk_mask) # Create 'motion corrupted stack', i.e. in-plane translation, and # associated ground-truth parameters parameters = np.zeros((shape_z, 3)) parameters[:, 0] = 0 nda_3D_corrupted = np.zeros_like(nda_3D) nda_3D_corrupted[0, :, :] = nda_3D[0, :, :] nda_3D_corrupted_mask = np.zeros_like(nda_3D_mask) nda_3D_corrupted_mask[0, :, :] = nda_3D_mask[0, :, :] for i in range(1, shape_z): # Get random translation [tx, ty] = np.random.randint(0, 50, 2) # Get image based on corruption inew = i0 + tx jnew = i0 + ty nda_3D_corrupted[i, inew:, jnew:] = \ nda_3D[i, i0:2*i0+length-tx, i0:2*i0+length-ty] nda_3D_corrupted_mask[i, inew:, jnew:] = \ nda_3D_mask[i, i0:2*i0+length-tx, i0:2*i0+length-ty] # Get ground-truth parameters parameters[i, 1] = ty parameters[i, 2] = tx # nda_3D_corrupted = np.zeros_like(nda_3D) # nda_3D_corrupted[0, i0:-i0, i0:-i0] = nda_2D # for i in range(1, shape_z): # # Get random translation # [tx, ty] = np.random.randint(0, 50, 2) # # Get image based on corruption # inew = i0 + tx # jnew = i0 + ty # nda_3D_corrupted[i, inew:inew+length, jnew:jnew+length] = nda_2D # # Get ground-truth parameters # parameters[i, 1] = ty # parameters[i, 2] = tx stack_corrupted_sitk = sitk.GetImageFromArray(nda_3D_corrupted) stack_corrupted_sitk_mask = sitk.GetImageFromArray( nda_3D_corrupted_mask) stack_corrupted = st.Stack.from_sitk_image(stack_corrupted_sitk, "stack_corrupted", stack_corrupted_sitk_mask) # stack_corrupted.show(1) # stack_corrupted.show_slices() # sitkh.show_stacks([stack, stack_corrupted], # segmentation=stack) # 1) Get initial transform in case no reference is given inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, use_stack_mask=True, ) inplane_registration.set_transform_initializer_type("moments") # inplane_registration.set_transform_initializer_type("identity") # inplane_registration.set_transform_initializer_type("geometry") inplane_registration._run_registration_pipeline_initialization() # Debug: # inplane_registration._apply_motion_correction() # stack_corrected = inplane_registration.get_corrected_stack() # sitkh.show_stacks( # [stack, # stack_corrupted, # stack_corrected.get_resampled_stack_from_slices( # interpolator="Linear", filename="stack_corrected")]) parameters_est = inplane_registration.get_parameters() nda_diff = parameters - parameters_est self.assertEqual( np.round(np.linalg.norm(nda_diff), decimals=self.accuracy), 0) # 2) Get initial transform in case reference is given inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, stack) inplane_registration.set_transform_initializer_type("moments") # inplane_registration.set_transform_initializer_type("identity") inplane_registration.use_reference_mask(True) inplane_registration.use_stack_mask_reference_fit_term(True) inplane_registration._run_registration_pipeline_initialization() # Debug: # inplane_registration._apply_motion_correction() # stack_corrected = inplane_registration.get_corrected_stack() # sitkh.show_stacks( # [stack, # stack_corrupted, # stack_corrected.get_resampled_stack_from_slices( # interpolator="Linear", filename="stack_corrected")]) parameters_est = inplane_registration.get_parameters() nda_diff = parameters - parameters_est # print(nda_diff) # print(parameters) self.assertEqual( np.round(np.linalg.norm(nda_diff), decimals=self.accuracy), 0)
def test_inplane_rigid_alignment_to_reference_multimodal(self): filename_stack = "fetal_brain_0" filename_recon = "FetalBrain_reconstruction_3stacks_myAlg" stack_tmp = st.Stack.from_filename( os.path.join(self.dir_test_data, filename_stack + ".nii.gz"), os.path.join(self.dir_test_data, filename_stack + "_mask.nii.gz")) recon = st.Stack.from_filename( os.path.join(self.dir_test_data, filename_recon)) recon_sitk = recon.get_resampled_stack_from_slices( resampling_grid=stack_tmp.sitk, interpolator="Linear").sitk stack = st.Stack.from_sitk_image(recon_sitk, "original", stack_tmp.sitk_mask) # recon_resampled_sitk = sitk.Resample(recon_sitk, stack_sitk) # stack = st.Stack.from_sitk_image(recon_resampled_sitk, "original") # Create in-plane motion corruption scale = 1.05 angle_z = 0.05 center_2D = (0, 0) translation_2D = np.array([1, -2]) intensity_scale = 1 intensity_bias = 0 # Get corrupted stack and corresponding motions stack_corrupted, motion_sitk, motion_2_sitk = get_inplane_corrupted_stack( stack, angle_z, center_2D, translation_2D, intensity_scale=intensity_scale, scale=scale, intensity_bias=intensity_bias) # stack_corrupted.show(1) # stack.show(1) # Perform in-plane rigid registration inplane_registration = inplanereg.IntraStackRegistration( stack_corrupted, stack) # inplane_registration = inplanereg.IntraStackRegistration(stack_corrupted) # inplane_registration.set_image_transform_reference_fit_term("gradient_magnitude") inplane_registration.set_image_transform_reference_fit_term( "partial_derivative") inplane_registration.set_transform_initializer_type("moments") # inplane_registration.set_transform_type("similarity") inplane_registration.set_intensity_correction_initializer_type(None) inplane_registration.set_intensity_correction_type_slice_neighbour_fit( None) inplane_registration.set_intensity_correction_type_reference_fit(None) inplane_registration.use_parameter_normalization(True) inplane_registration.use_verbose(True) inplane_registration.set_optimizer_loss( "linear") # linear, soft_l1, huber inplane_registration.set_alpha_reference(100) inplane_registration.set_alpha_neighbour(0) inplane_registration.set_alpha_parameter(1) # inplane_registration.use_stack_mask(True) # inplane_registration.use_reference_mask(True) inplane_registration.set_optimizer_iter_max(10) inplane_registration.run() inplane_registration.print_statistics() stack_registered = inplane_registration.get_corrected_stack() parameters = inplane_registration.get_parameters() sitkh.show_stacks([ stack, stack_corrupted, stack_registered.get_resampled_stack_from_slices( resampling_grid=None, interpolator="Linear") ]) # print("Final parameters:") # print(parameters) # self.assertEqual(np.round( # np.linalg.norm(parameters[:,-1] - intensity_scale) # , decimals = 0), 0) # 2) Test slice transforms slice_transforms_sitk = inplane_registration.get_slice_transforms_sitk( ) stack_tmp = st.Stack.from_stack(stack_corrupted) stack_tmp.update_motion_correction_of_slices(slice_transforms_sitk) stack_diff_sitk = stack_tmp.get_resampled_stack_from_slices( resampling_grid=stack.sitk ).sitk - stack_registered.get_resampled_stack_from_slices( resampling_grid=stack.sitk).sitk stack_diff_nda = sitk.GetArrayFromImage(stack_diff_sitk) self.assertEqual(np.round(np.linalg.norm(stack_diff_nda), decimals=8), 0)