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)
