def test_heatmap(tmpdir): tmpdir = Path(tmpdir) heatmap_file_test = tmpdir / "heatmap_test.nii" args = [ "heatmap", str(xml_file), str(heatmap_file_test), str(raw_data), str(atlas), "-x", "50", "-y", "50", "-z", "50", "--bin-size", "250", "--heatmap-smoothing", "250", ] sys.argv = args heatmap_run() heatmap_data = brainio.load_nii(heatmap, as_numpy=True).get_fdata() heatmap_test_data = brainio.load_nii( heatmap_file_test, as_numpy=True ).get_fdata() assert (heatmap_data == heatmap_test_data).all()
def are_images_equal(image_name, output_directory, test_output_directory): image = load_nii(os.path.join(output_directory, image_name), as_array=True) test_image = load_nii( os.path.join(test_output_directory, image_name), as_array=True ) assert (image == test_image).all()
def load_all(self): if self._data is None: self._data = brainio.load_nii(self.get_path()) if self._brain_data is None: self._brain_data = brainio.load_nii(self.get_brain_path()) if self._hemispheres_data is None: self._hemispheres_data = brainio.load_nii( self.get_hemispheres_path())
def are_images_equal(image_name, output_directory, test_output_directory): image = load_nii( os.path.join(output_directory, image_name), as_array=True, as_numpy=True, ) test_image = load_nii( os.path.join(test_output_directory, image_name), as_array=True, as_numpy=True, ) np.testing.assert_allclose(image, test_image, rtol=relative_tolerance, atol=absolute_tolerance)
def get_transform_space_params(registration_config, destination_image): atlas = brainio.load_nii(str(destination_image), as_array=False) atlas_scale = atlas.header.get_zooms() atlas_pixel_sizes = get_atlas_pixel_sizes(registration_config) transformation_matrix = np.eye(4) for i, axis in enumerate(("x", "y", "z")): transformation_matrix[i, i] = atlas_pixel_sizes[axis] return atlas_scale, transformation_matrix
def _get_figure_image_shape(self): logging.debug("Loading file: {} to check target image size" "".format(self._target_image)) self._downsampled_image = brainio.load_nii(self._target_image, as_array=False) shape = self._downsampled_image.shape self.figure_image_shape = {"x": shape[0], "y": shape[1], "z": shape[2]} logging.debug("Target image size: {}".format(self.figure_image_shape))
def get_data(self): """ Load the atlas and return it :return: The atlas (nifty image) """ atlas_path = self.get_path() if self._data is None: self._data = brainio.load_nii(atlas_path) return self._data
def generate_region_volume(structure_names, atlas_path, output_path, atlas_config, glass=False): structure_csv_file = get_structures_path() reference_structures_table = pd.read_csv(structure_csv_file) # ensure all names are valid for indv_structure_name in structure_names: try: get_substructures(indv_structure_name, reference_structures_table) except IndexError: raise ValueError( f"Brain region: '{indv_structure_name}' cannot be found " f"in file: {structure_csv_file}. Please choose " f"another structure.") print(f"Loading atlas from: {atlas_path}") atlas = brainio.load_nii(atlas_path, as_array=False) atlas_scale = atlas.header.get_zooms() atlas = atlas.get_data() transformation_matrix = brain_tools.get_transformation_matrix(atlas_config) if len(structure_names) > 1: # Initialise an image to add each subimage to. final_image = np.zeros_like(atlas) for indv_structure_name in structure_names: print(f"Analysing brain region: {indv_structure_name}") substructures = get_substructures(indv_structure_name, reference_structures_table) print("This includes structures:") indv_substructure_names = substructures["name"].values for indv_substructure_name in indv_substructure_names: print(indv_substructure_name) list_vals = substructures["id"].values print("Generating image with specified regions \n") sub_image = np.isin(atlas, list_vals) if glass: print("Generating glass brain") sub_image = sk_segmentation.find_boundaries(sub_image) # If multiple structures, add them together if len(structure_names) > 1: final_image = np.logical_or(final_image, sub_image) else: final_image = sub_image print("Converting image to 16 bit") final_image = tools.scale_and_convert_to_16_bits(final_image) print("Saving image") brainio.to_nii( final_image, output_path, scale=atlas_scale, affine_transform=transformation_matrix, ) print(f"Saved image at: {output_path}")
def test_tiff_to_nii(tmpdir, start_array): tiffs_folder = str(tmpdir.mkdir("tiffs")) brainio.to_tiffs(start_array, os.path.join(tiffs_folder, "start_array")) nii_path = os.path.join(str(tmpdir), "test_array.nii.gz") brainio.tiff_to_nii(tiffs_folder, nii_path) assert (brainio.load_nii(nii_path).get_data() == start_array).all()
def test_to_nii(tmpdir, start_array): # Also tests load_nii folder = str(tmpdir) nii_path = os.path.join(folder, "test_array.nii") brainio.to_nii(start_array, nii_path) assert (brainio.load_nii(nii_path).get_data() == start_array).all()
def main(): start_time = datetime.now() print("Starting ROI transformation") args = get_parser().parse_args() rois = args.rois print(f"ROI file is: {rois}") if args.registration_config is None: args.registration_config = source_custom_config() atlas = Atlas(args.registration_config) source_image = args.reg_dir / SOURCE_IMAGE_NAME print(f"Source image is: {source_image}") destination_image = args.reg_dir / atlas.atlas_conf["default_brain_name"] print(f"Destination image is: {destination_image}") control_point_file = args.reg_dir / DEFAULT_CONTROL_POINT_FILE print(f"Transformation file is: {control_point_file}") if args.output_filename is None: output_filename = rois.parent / DEFAULT_OUTPUT_FILE_NAME temp_output_filename = rois.parent / DEFAULT_TEMP_FILE_NAME log_file_path = rois.parent / "roi_transform_log.txt" error_file_path = rois.parent / "roi_transform_error.txt" else: output_filename = args.output_filename temp_output_filename = (args.output_filename.parent / DEFAULT_TEMP_FILE_NAME) log_file_path = args.output_filename.parent / "roi_transform_log.txt" error_file_path = (args.output_filename.parent / "roi_transform_error.txt") if not output_filename.parent.exists(): output_filename.parent.mkdir() print(f"Output file is: {output_filename}") atlas = brainio.load_nii(str(destination_image), as_array=False) atlas_scale = atlas.header.get_zooms() atlas_pixel_sizes = cells_regions.get_atlas_pixel_sizes( args.registration_config) transformation_matrix = np.eye(4) for i, axis in enumerate(("x", "y", "z")): transformation_matrix[i, i] = atlas_pixel_sizes[axis] transform_rois( rois, source_image, destination_image, control_point_file, output_filename, temp_output_filename, log_file_path, error_file_path, roi_reference_image=args.reference_image, selem_size=args.selem_size, nii_scale=atlas_scale, transformation_matrix=transformation_matrix, debug=args.debug, z_filter_padding=args.z_filter_padding, ) print("Finished. Total time taken: {}".format(datetime.now() - start_time))
def get_nii_from_element(self, element_name): """ This can be easily changed to a different loading API if needed. """ data_full_path = self.base_folder / self[element_name] return brainio.load_nii(data_full_path)
def get_atlas(self): atlas_img = brainio.load_nii(self._atlas_path, as_array=False) self.atlas_scale = atlas_img.header.get_zooms() self.atlas = np.asanyarray(atlas_img.dataobj) self.get_transformation_matrix()
def get_atlas(self): atlas = brainio.load_nii(self._atlas_path, as_array=False) self.atlas_scale = atlas.header.get_zooms() self.atlas = atlas.get_data() self.get_transformation_matrix()
def _get_atlas_data(self): self.atlas_data = brainio.load_nii(self._target_image, as_array=True)