def get_deformed_image_sitk(self, fixed_sitk, moving_sitk, interpolation_order): # REMARK: # Not possible to write registration transform that way since # some header information gets lost! Therefore, read again the one # which was the output of NiftyReg (and hope that file is not been # deleted) # Create and delete all possibly existing files in the directory # ph.create_directory(self._dir_tmp, delete_files=True) # sitkh.write_nifti_image_sitk(self.get_registration_transform_sitk(), # self._registration_control_point_grid_str) sitkh.write_nifti_image_sitk(fixed_sitk, self._fixed_str) sitkh.write_nifti_image_sitk(moving_sitk, self._moving_str) nreg = nipype.interfaces.niftyreg.RegResample() nreg.inputs.ref_file = self._fixed_str nreg.inputs.flo_file = self._moving_str nreg.inputs.trans_file = self._registration_control_point_grid_str nreg.inputs.out_file = self._warped_moving_str nreg.inputs.omp_core_val = self._omp nreg.inputs.args = "-inter " + str(interpolation_order) # Execute registration if self._verbose: ph.print_execution(nreg.cmdline) nreg.run() return sitkh.read_nifti_image_sitk(self._warped_moving_str, moving_sitk.GetPixelIDValue())
def split_labels(path_to_labels, dimension, path_to_output): if dimension == 4: labels_nib = nib.load(path_to_labels) nda = labels_nib.get_data().astype(np.uint8) else: labels_sitk = sitk.ReadImage(path_to_labels) nda = sitk.GetArrayFromImage(labels_sitk).astype(np.uint8) # split labels into separate components n_labels = nda.max() shape = nda.shape + (n_labels, ) nda_4d = np.zeros((shape), dtype=np.uint8) for label in range(n_labels): indices = np.where(nda == label + 1) indices += (label * np.ones(len(indices[0]), dtype=np.uint8), ) nda_4d[indices] = 1 if dimension == 4: labels_4d_nib = nib.Nifti1Image(nda_4d, affine=labels_nib.affine, header=labels_nib.header) labels_4d_nib.set_data_dtype(np.uint8) ph.create_directory(os.path.dirname(path_to_output)) nib.save(labels_4d_nib, path_to_output) else: labels_5d_sitk = sitk.GetImageFromArray(nda_4d) labels_5d_sitk.SetOrigin(labels_sitk.GetOrigin()) labels_5d_sitk.SetSpacing(labels_sitk.GetSpacing()) labels_5d_sitk.SetDirection(labels_sitk.GetDirection()) sitkh.write_nifti_image_sitk(labels_5d_sitk, path_to_output)
def test_read_write_nifti_image_sitk(self): image_sitk = sitk.ReadImage(os.path.join( self.dir_test_data, self.filename + ".nii.gz")) foo = os.path.join(DIR_TMP, "foo.nii.gz") sitkh.write_nifti_image_sitk(image_sitk, foo) foo_sitk = sitkh.read_nifti_image_sitk(foo) nda = sitk.GetArrayFromImage(image_sitk - foo_sitk) error = np.linalg.norm(nda) self.assertAlmostEqual(error, 0, places=self.accuracy)
def write_mask(mask_sitk, path_to_file, compress=True, verbose=True): info = "Write mask to %s" % path_to_file if compress: mask_sitk = sitk.Cast(mask_sitk, sitk.sitkUInt8) info += " (uint8)" if verbose: ph.print_info("%s ... " % info, newline=False) sitkh.write_nifti_image_sitk(mask_sitk, path_to_file) if verbose: print("done")
def write_image(image_sitk, path_to_file, compress=True, verbose=True): info = "Write image to %s" % path_to_file if compress: image_sitk = sitk.Cast(image_sitk, sitk.sitkFloat32) info += " (float32)" if verbose: ph.print_info("%s ... " % info, newline=False) sitkh.write_nifti_image_sitk(image_sitk, path_to_file) if verbose: print("done")
def save_landmarks_to_image(self, path_to_file): if self._landmarks_image_space is None: raise RuntimeError("Execute 'run' first to estimate landmarks") ph.print_info("Save landmarks to image '%s' ... " % path_to_file, newline=False) # read original image image_label_sitk = sitk.ReadImage(self._path_to_image_label) image_label_nda = sitk.GetArrayFromImage(image_label_sitk) * 0 # convert to integer voxels image_label_nda = self._get_array_with_landmarks( image_label_sitk.GetSize()[::-1], self._landmarks_voxel_space) # landmarks_voxel_space = self._landmarks_voxel_space.astype('int') # for i in range(landmarks_voxel_space.shape[0]): # image_label_nda[landmarks_voxel_space[i, 2], # landmarks_voxel_space[i, 1], # landmarks_voxel_space[i, 0]] = 1 image_landmarks_sitk = sitk.GetImageFromArray(image_label_nda) image_landmarks_sitk.CopyInformation(image_label_sitk) sitkh.write_nifti_image_sitk(image_landmarks_sitk, path_to_file) print("done") # show landmark estimate if self._verbose: # find bounding box for "zoomed in" visualization ran_x, ran_y, ran_z = self._get_bounding_box(image_label_nda) # get zoomed-in image mask image_label_nda_show = image_label_nda[ran_x[0]:ran_x[1], ran_y[0]:ran_y[1], ran_z[0]:ran_z[1]] landmarks_nda = self._get_array_with_landmarks( image_label_nda.shape, self._landmarks_voxel_space) show_mask_sitk = sitk.GetImageFromArray(image_label_nda_show) # get zoomed-in landmark estimate (dilated for visualization) landmarks_nda_show = landmarks_nda[ran_x[0]:ran_x[1], ran_y[0]:ran_y[1], ran_z[0]:ran_z[1]] landmarks_nda_show += scipy.ndimage.morphology.binary_dilation( landmarks_nda_show, iterations=10) show_landmarks_sitk = sitk.GetImageFromArray(landmarks_nda_show) sitkh.show_sitk_image(show_mask_sitk, segmentation=show_landmarks_sitk, label=os.path.basename( ph.strip_filename_extension( self._path_to_image_label)[0]))
def write_image(image_sitk, path_to_file, verbose=0): extension = ph.strip_filename_extension(path_to_file)[1] if extension not in ALLOWED_IMAGES: raise IOError("Image file extension must be of type %s " % ", or ".join(ALLOWED_IMAGES)) if isinstance(image_sitk, sitk.Image): sitkh.write_nifti_image_sitk(image_sitk=image_sitk, path_to_file=path_to_file, verbose=verbose) else: sitkh.write_nifti_image_itk(image_itk=image_sitk, path_to_file=path_to_file, verbose=verbose)
def write_transform(transform_sitk, path_to_file, verbose=0): extension = ph.strip_filename_extension(path_to_file)[1] if extension not in ALLOWED_TRANSFORMS and \ extension not in ALLOWED_TRANSFORMS_DISPLACEMENTS: raise IOError("Transform file extension must be of type " "%s (transformation) or %s (displacements)" % (", ".join(ALLOWED_TRANSFORMS), ", ".join(ALLOWED_TRANSFORMS_DISPLACEMENTS))) if extension in ALLOWED_TRANSFORMS: if isinstance(transform_sitk, sitk.Image): raise IOError("Cannot convert displacement field (%s) to " "transform (%s)" % ( ", ".join(ALLOWED_TRANSFORMS_DISPLACEMENTS), ", ".join(ALLOWED_TRANSFORMS), )) if isinstance(transform_sitk, sitk.Transform): ph.create_directory(os.path.dirname(path_to_file)) sitk.WriteTransform(transform_sitk, path_to_file) if verbose: ph.print_info("Transform written to '%s'" % path_to_file) elif isinstance(transform_sitk, np.ndarray): ph.write_array_to_file(path_to_file, transform_sitk, delimiter=" ", access_mode="w", verbose=verbose) else: raise IOError("Transform must be of type " "sitk.Transform or np.ndarray") else: if isinstance(transform_sitk, sitk.Transform): raise IOError("Cannot convert transform (%s) to " "displacement field (%s)" % ( ", ".join(ALLOWED_TRANSFORMS), ", ".join(ALLOWED_TRANSFORMS_DISPLACEMENTS), )) elif isinstance(transform_sitk, sitk.Image): sitkh.write_nifti_image_sitk(image_sitk=transform_sitk, path_to_file=path_to_file, verbose=verbose) elif isinstance(transform_sitk, nib.nifti1.Nifti1Image): ph.create_directory(os.path.dirname(path_to_file)) nib.save(transform_sitk, path_to_file) else: raise IOError("Transform must be of type " "sitk.Image or nibabel.nifti1.Nifti1Image")
def _run_bet_for_brain_stripping(self, debug=0): filename_out = "image" self._dir_tmp = ph.create_directory(self._dir_tmp, delete_files=True) path_to_image = os.path.join(self._dir_tmp, filename_out + ".nii.gz") path_to_res = os.path.join(self._dir_tmp, filename_out + "_bet.nii.gz") path_to_res_mask = os.path.join(self._dir_tmp, filename_out + "_bet_mask.nii.gz") path_to_res_skull = os.path.join(self._dir_tmp, filename_out + "_bet_skull.nii.gz") sitkh.write_nifti_image_sitk(self._sitk, path_to_image) bet = nipype.interfaces.fsl.BET() bet.inputs.in_file = path_to_image bet.inputs.out_file = path_to_res options = "" if not self._compute_brain_image: options += "-n " if self._compute_brain_mask: options += "-m " if self._compute_skull_image: options += "-s " options += self._bet_options bet.inputs.args = options if debug: print(bet.cmdline) bet.run() if self._compute_brain_image: self._sitk_brain_image = sitkh.read_nifti_image_sitk( path_to_res, sitk.sitkFloat64) if self._compute_brain_mask: self._sitk_brain_mask = sitkh.read_nifti_image_sitk( path_to_res_mask, sitk.sitkUInt8) if self._compute_skull_image: self._sitk_skull_image = sitkh.read_nifti_image_sitk( path_to_res_skull)
def test_affine_transform_reg_aladin(self): # Read data filename_fixed = "stack1_rotated_angle_z_is_pi_over_10.nii.gz" filename_moving = "FetalBrain_reconstruction_3stacks_myAlg.nii.gz" diff_ref = os.path.join( DIR_TEST, "stack1_rotated_angle_z_is_pi_over_10_nreg_diff.nii.gz") moving = st.Stack.from_filename( os.path.join(self.dir_test_data, filename_moving), ) fixed = st.Stack.from_filename( os.path.join(self.dir_test_data, filename_fixed)) # Set up NiftyReg nifty_reg = nreg.RegAladin() nifty_reg.set_fixed(fixed) nifty_reg.set_moving(moving) nifty_reg.set_registration_type("Rigid") nifty_reg.use_verbose(False) # Register via NiftyReg nifty_reg.run() # Get associated results affine_transform_sitk = nifty_reg.get_registration_transform_sitk() moving_warped = nifty_reg.get_warped_moving() # Get SimpleITK result with "similar" interpolator (NiftyReg does not # state what interpolator is used but it seems to be BSpline) moving_warped_sitk = sitk.Resample(moving.sitk, fixed.sitk, affine_transform_sitk, sitk.sitkBSpline, 0.0, moving.sitk.GetPixelIDValue()) diff_res_sitk = moving_warped.sitk - moving_warped_sitk sitkh.write_nifti_image_sitk(diff_res_sitk, diff_ref) diff_ref_sitk = sitk.ReadImage(diff_ref) res_diff_nda = sitk.GetArrayFromImage(diff_res_sitk - diff_ref_sitk) self.assertAlmostEqual(np.linalg.norm(res_diff_nda), 0, places=self.accuracy)
def write_mask( mask_sitk, path_to_file, compress=True, verbose=True, description=None, ): info = "Write mask to %s" % path_to_file if compress: mask_sitk = sitk.Cast(mask_sitk, sitk.sitkUInt8) info += " (uint8)" if verbose: ph.print_info("%s ... " % info, newline=False) header_update = DataWriter._get_header_update(description=description) sitkh.write_nifti_image_sitk(mask_sitk, path_to_file, header_update=header_update) if verbose: print("done")
def run(self): ph.create_directory(dir_tmp, delete_files=True) # Write images sitkh.write_nifti_image_sitk( self._stack1.sitk, self._dir_tmp + self._stack1.get_filename() + ".nii.gz") sitkh.write_nifti_image_sitk( self._stack2.sitk, self._dir_tmp + self._stack2.get_filename() + ".nii.gz") cmd = "siena " cmd += self._dir_tmp + self._stack1.get_filename() + ".nii.gz " cmd += self._dir_tmp + self._stack2.get_filename() + ".nii.gz " cmd += "-o " + self._dir_output + " " cmd += self._options time_start = ph.start_timing() ph.execute_command(cmd) self._elapsed_time = ph.stop_timing(time_start) # Extract measures from report self._extract_percentage_brain_volume_change()
def write(self, directory, filename=None, write_transform=False, suffix_mask="_mask", prefix_slice="_slice"): # Create directory if not existing ph.create_directory(directory) # Construct filename if filename is None: filename_out = self._filename + \ prefix_slice + str(self._slice_number) else: filename_out = filename + prefix_slice + str(self._slice_number) full_file_name = os.path.join(directory, filename_out) # Write slice and affine transform sitkh.write_nifti_image_sitk(self.sitk, full_file_name + ".nii.gz") if write_transform: sitk.WriteTransform( # self.get_affine_transform(), self.get_motion_correction_transform(), full_file_name + ".tfm") # Write mask to specified location if given if self.sitk_mask is not None: nda = sitk.GetArrayFromImage(self.sitk_mask) # Write mask if it does not consist of only ones if not np.all(nda): sitkh.write_nifti_image_sitk( self.sitk_mask, full_file_name + "%s.nii.gz" % (suffix_mask))
def _run_registrations(self, transformations): path_to_fixed = os.path.join(DIR_TMP, "fixed.nii.gz") path_to_moving = os.path.join(DIR_TMP, "moving.nii.gz") path_to_fixed_mask = os.path.join(DIR_TMP, "fixed_mask.nii.gz") path_to_moving_mask = os.path.join(DIR_TMP, "moving_mask.nii.gz") path_to_tmp_output = os.path.join(DIR_TMP, "foo.nii.gz") path_to_transform_regaladin = os.path.join(DIR_TMP, "transform_regaladin.txt") path_to_transform_sitk = os.path.join(DIR_TMP, "transform_sitk.txt") sitkh.write_nifti_image_sitk(self._fixed.sitk, path_to_fixed) sitkh.write_nifti_image_sitk(self._moving.sitk, path_to_moving) sitkh.write_nifti_image_sitk(self._fixed.sitk_mask, path_to_fixed_mask) # sitkh.write_nifti_image_sitk( # self._moving.sitk_mask, path_to_moving_mask) for i in range(len(transformations)): sitk.WriteTransform(transformations[i], path_to_transform_sitk) # Convert SimpleITK to RegAladin transform cmd = "simplereg_transform -sitk2nreg %s %s" % ( path_to_transform_sitk, path_to_transform_regaladin) ph.execute_command(cmd, verbose=False) # Run NiftyReg cmd_args = ["reg_aladin"] cmd_args.append("-ref %s" % path_to_fixed) cmd_args.append("-flo %s" % path_to_moving) cmd_args.append("-res %s" % path_to_tmp_output) cmd_args.append("-inaff %s" % path_to_transform_regaladin) cmd_args.append("-aff %s" % path_to_transform_regaladin) cmd_args.append("-rigOnly") cmd_args.append("-ln 2") cmd_args.append("-voff") cmd_args.append("-rmask %s" % path_to_fixed_mask) # To avoid error "0 correspondences between blocks were found" that can # occur for some cases. Also, disable moving mask, as this would be ignored # anyway cmd_args.append("-noSym") ph.print_info( "Run Registration (RegAladin) based on PCA-init %d ... " % (i + 1)) ph.execute_command(" ".join(cmd_args), verbose=False) # Convert RegAladin to SimpleITK transform cmd = "simplereg_transform -nreg2sitk %s %s" % ( path_to_transform_regaladin, path_to_transform_sitk) ph.execute_command(cmd, verbose=False) transformations[i] = sitkh.read_transform_sitk( path_to_transform_sitk) return transformations
def _run(self): # Create and delete all possibly existing files in the directory ph.create_directory(self._dir_tmp, delete_files=True) sitkh.write_nifti_image_sitk(self._fixed_sitk, self._fixed_str) sitkh.write_nifti_image_sitk(self._moving_sitk, self._moving_str) if self._fixed_sitk_mask is not None: sitkh.write_nifti_image_sitk( self._fixed_sitk_mask, self._fixed_mask_str) if self._moving_sitk_mask is not None: sitkh.write_nifti_image_sitk( self._moving_sitk_mask, self._moving_mask_str) if self._transform_init is not None: ph.write_array_to_file( self._transform_init_str, self._transform_init, access_mode="a", verbose=0)
def _run(self): # Create and delete all possibly existing files in the directory ph.create_directory(self._dir_tmp, delete_files=True) sitkh.write_nifti_image_sitk(self._fixed_sitk, self._fixed_str) sitkh.write_nifti_image_sitk(self._moving_sitk, self._moving_str) flt = nipype.interfaces.fsl.FLIRT() flt.inputs.in_file = self._moving_str flt.inputs.reference = self._fixed_str flt.inputs.out_file = self._warped_moving_str flt.inputs.out_matrix_file = self._registration_transform_str flt.inputs.output_type = "NIFTI_GZ" if self._fixed_sitk_mask is not None: sitkh.write_nifti_image_sitk(self._fixed_sitk_mask, self._fixed_mask_str) flt.inputs.ref_weight = self._fixed_mask_str if self._moving_sitk_mask is not None: sitkh.write_nifti_image_sitk(self._moving_sitk_mask, self._moving_mask_str) flt.inputs.in_weight = self._moving_mask_str flt.inputs.args = self._options # Execute registration if self._verbose: ph.print_execution(flt.cmdline) flt.run() # Read warped image self._warped_moving_sitk = sitkh.read_nifti_image_sitk( self._warped_moving_str) # Convert to sitk affine transform self._registration_transform_sitk = self._convert_to_sitk_transform()
def _run_registration_inplane_similarity_3D(self, id, endl=" \\\n"): if self._fixed is None or self._moving is None: raise ValueError("Error: Fixed and moving image not specified") if self._use_verbose: verbose = "1" else: verbose = "0" # Clean output directory first os.system("rm -rf " + self._dir_tmp + "*") moving_str = "RegistrationITK_moving_" + id + self._moving.get_filename( ) fixed_str = "RegistrationITK_fixed_" + id + self._fixed.get_filename() moving_mask_str = "RegistrationITK_moving_mask_" + id + self._moving.get_filename( ) fixed_mask_str = "RegistrationITK_fixed_mask_" + id + self._fixed.get_filename( ) registration_transform_str = "RegistrationITK_transform_" + id + \ self._fixed.get_filename() + "_" + self._moving.get_filename() # Write images to HDD # if not os.path.isfile(self._dir_tmp + moving_str + ".nii.gz"): sitkh.write_nifti_image_sitk(self._moving.sitk, self._dir_tmp + moving_str + ".nii.gz") # if not os.path.isfile(self._dir_tmp + fixed_str + ".nii.gz"): sitkh.write_nifti_image_sitk(self._fixed.sitk, self._dir_tmp + fixed_str + ".nii.gz") # if not os.path.isfile(self._dir_tmp + moving_mask_str + ".nii.gz") # and self._use_moving_mask: sitkh.write_nifti_image_sitk( self._moving.sitk_mask, self._dir_tmp + moving_mask_str + ".nii.gz") # if not os.path.isfile(self._dir_tmp + fixed_mask_str + ".nii.gz") and # self._use_fixed_mask: sitkh.write_nifti_image_sitk( self._fixed.sitk_mask, self._dir_tmp + fixed_mask_str + ".nii.gz") # Prepare command for execution cmd = DIR_CPP_BUILD + "/bin/itkInplaneSimilarity3DReg" + endl cmd += "--f " + self._dir_tmp + fixed_str + ".nii.gz" + endl cmd += "--m " + self._dir_tmp + moving_str + ".nii.gz" + endl if self._use_fixed_mask: cmd += "--fmask " + self._dir_tmp + fixed_mask_str + ".nii.gz" + endl if self._use_moving_mask: cmd += "--mmask " + self._dir_tmp + moving_mask_str + ".nii.gz" + endl cmd += "--tout " + self._dir_tmp + registration_transform_str + ".txt" + endl cmd += "--useAffine " + \ str(int(self._registration_type is "Affine")) + endl cmd += "--useMultires " + \ str(int(self._use_multiresolution_framework)) + endl cmd += "--metric " + self._metric + endl cmd += "--scalesEst " + self._scales_estimator + endl cmd += "--interpolator " + self._interpolator + endl cmd += "--ANTSrad " + str(self._ANTSradius) + endl # cmd += "--translationScale " + str(self._translation_scale) + endl cmd += "--verbose " + verbose + endl # Compute oriented Gaussian PSF if desired if self._interpolator in ["OrientedGaussian"]: if self._cov is None: # Get oriented Gaussian covariance matrix cov_HR_coord = psf.PSF().\ get_covariance_matrix_in_reconstruction_space( self._moving, self._fixed).flatten() else: cov_HR_coord = self._cov.flatten() cmd += "--cov " + "'" + ' '.join(cov_HR_coord.astype("|S12")) + "'" # if self._use_verbose: ph.execute_command(cmd) # Read transformation file params_all = np.loadtxt(self._dir_tmp + registration_transform_str + ".txt") ## (center_x, center_y, center_z, direction_fixed_image_flattened_0, ..., direction_fixed_image_flattened_8) self._parameters_fixed = params_all[0:-7] ## (versor_0, versor_1, versor_2, translation_x, translation_y, translation_z, scale) self._parameters = params_all[-7:] # Get affine registration transform T(x) = R D Lambda D^{-1} (x-c) + t # + c self._registration_transform_sitk = self._get_affine_transform_from_similarity_registration( )
def _run_registration_rigid_affine(self, id, endl=" \\\n"): if self._fixed is None or self._moving is None: raise ValueError("Error: Fixed and moving image not specified") if self._use_verbose: verbose = "1" else: verbose = "0" moving_str = "RegistrationITK_moving_" + id + self._moving.get_filename( ) fixed_str = "RegistrationITK_fixed_" + id + self._fixed.get_filename() moving_mask_str = "RegistrationITK_moving_mask_" + id + self._moving.get_filename( ) fixed_mask_str = "RegistrationITK_fixed_mask_" + id + self._fixed.get_filename( ) registration_transform_str = "RegistrationITK_transform_" + id + \ self._fixed.get_filename() + "_" + self._moving.get_filename() # Write images to HDD # if not os.path.isfile(self._dir_tmp + moving_str + ".nii.gz"): sitkh.write_nifti_image_sitk(self._moving.sitk, self._dir_tmp + moving_str + ".nii.gz") # if not os.path.isfile(self._dir_tmp + fixed_str + ".nii.gz"): sitkh.write_nifti_image_sitk(self._fixed.sitk, self._dir_tmp + fixed_str + ".nii.gz") # if not os.path.isfile(self._dir_tmp + moving_mask_str + ".nii.gz") # and self._use_moving_mask: sitkh.write_nifti_image_sitk( self._moving.sitk_mask, self._dir_tmp + moving_mask_str + ".nii.gz") # if not os.path.isfile(self._dir_tmp + fixed_mask_str + ".nii.gz") and # self._use_fixed_mask: sitkh.write_nifti_image_sitk( self._fixed.sitk_mask, self._dir_tmp + fixed_mask_str + ".nii.gz") # Prepare command for execution # cmd = "/Users/mebner/UCL/UCL/Software/Volumetric\ Reconstruction/build/cpp/bin/itkReg " cmd = DIR_CPP_BUILD + "/bin/itkReg" + endl cmd += "--f " + self._dir_tmp + fixed_str + ".nii.gz" + endl cmd += "--m " + self._dir_tmp + moving_str + ".nii.gz" + endl if self._use_fixed_mask: cmd += "--fmask " + self._dir_tmp + fixed_mask_str + ".nii.gz" + endl if self._use_moving_mask: cmd += "--mmask " + self._dir_tmp + moving_mask_str + ".nii.gz" + endl cmd += "--tout " + self._dir_tmp + registration_transform_str + ".txt" + endl cmd += "--useAffine " + \ str(int(self._registration_type is "Affine")) + endl cmd += "--useMultires " + \ str(int(self._use_multiresolution_framework)) + endl cmd += "--metric " + self._metric + endl cmd += "--scalesEst " + self._scales_estimator + endl cmd += "--interpolator " + self._interpolator + endl cmd += "--ANTSrad " + str(self._ANTSradius) + endl cmd += "--verbose " + verbose + endl # Compute oriented Gaussian PSF if desired if self._interpolator in ["OrientedGaussian"]: if self._cov is None: # Get oriented Gaussian covariance matrix cov_HR_coord = psf.PSF().\ get_covariance_matrix_in_reconstruction_space( self._moving, self._fixed).flatten() else: cov_HR_coord = self._cov.flatten() cmd += "--cov " + "'" + ' '.join(cov_HR_coord.astype("|S12")) + "'" ph.execute_command(cmd, verbose=0) # Read transformation file params_all = np.loadtxt(self._dir_tmp + registration_transform_str + ".txt") if self._registration_type in ["Rigid"]: self._parameters_fixed = params_all[0:4] self._parameters = params_all[4:] self._registration_transform_sitk = sitk.Euler3DTransform() else: self._parameters_fixed = params_all[0:3] self._parameters = params_all[3:] self._registration_transform_sitk = sitk.AffineTransform(3) self._registration_transform_sitk.SetParameters(self._parameters) self._registration_transform_sitk.SetFixedParameters( self._parameters_fixed)
def write(self, directory, filename=None, write_mask=False, write_slices=False, write_transforms=False, suffix_mask="_mask"): # Create directory if not existing ph.create_directory(directory) # Construct filename if filename is None: filename = self._filename full_file_name = os.path.join(directory, filename) # Write file to specified location ph.print_info("Write image stack to %s.nii.gz ... " % (full_file_name), newline=False) sitkh.write_nifti_image_sitk(self.sitk, full_file_name + ".nii.gz") print("done") # Write mask to specified location if given if self.sitk_mask is not None: # nda = sitk.GetArrayFromImage(self.sitk_mask) # Write mask if it does not consist of only ones if not self._is_unity_mask and write_mask: ph.print_info("Write image stack mask to %s%s.nii.gz ... " % ( full_file_name, suffix_mask), newline=False) sitkh.write_nifti_image_sitk( self.sitk_mask, full_file_name + "%s.nii.gz" % ( suffix_mask)) print("done") # print("Stack was successfully written to %s.nii.gz" # %(full_file_name)) # Write each separate Slice of stack (if they exist) if write_slices: try: # Check whether variable exists # if 'self._slices' not in locals() or all(i is None for i in # self._slices): if not hasattr(self, '_slices'): raise ValueError( "Error occurred in attempt to write %s.nii.gz: " "No separate slices of object Slice are found" % full_file_name) # Write slices else: if write_transforms: ph.print_info( "Write image slices + transforms to %s ... " % directory, newline=False) else: ph.print_info( "Write image slices to %s ... " % directory, newline=False) for slice in self.get_slices(): slice.write( directory=directory, filename=filename, write_transform=write_transforms, suffix_mask=suffix_mask) print("done") except ValueError as err: print(err.message)