def test_delete_tmp(tmpdir):
tmpdir = Path(tmpdir)
paths = Paths(tmpdir)
for attr, path in paths.__dict__.items():
path.touch()
print(path)
assert len([child for child in tmpdir.iterdir()]) == 4
system.delete_temp(tmpdir, paths)
assert len([child for child in tmpdir.iterdir()]) == 2
system.delete_temp(tmpdir, paths)
def transform_cells_to_standard_space(args):
if args.registration_config is None:
args.registration_config = source_custom_config_cellfinder()
reg_params = RegistrationParams(
args.registration_config,
affine_n_steps=args.affine_n_steps,
affine_use_n_steps=args.affine_use_n_steps,
freeform_n_steps=args.freeform_n_steps,
freeform_use_n_steps=args.freeform_use_n_steps,
bending_energy_weight=args.bending_energy_weight,
grid_spacing=args.grid_spacing,
smoothing_sigma_reference=args.smoothing_sigma_reference,
smoothing_sigma_floating=args.smoothing_sigma_floating,
histogram_n_bins_floating=args.histogram_n_bins_floating,
histogram_n_bins_reference=args.histogram_n_bins_reference,
)
generate_deformation_field(args, reg_params)
cells_only = not args.transform_all
cells = get_cells(
args.paths.classification_out_file, cells_only=cells_only
)
logging.info("Loading deformation field")
deformation_field = load_any_image(
args.paths.tmp__deformation_field, as_numpy=True
)
scales = get_scales(args, reg_params)
field_scales = get_deformation_field_scales(reg_params)
logging.info("Transforming cell positions")
transformed_cells = transform_cell_positions(
cells, deformation_field, field_scales, scales
)
logging.info("Saving transformed cell positions")
save_cells(
transformed_cells,
args.paths.cells_in_standard_space,
save_csv=args.save_csv,
)
if not args.debug:
logging.info("Removing standard space transformation temp files")
delete_temp(args.paths.standard_space_output_folder, args.paths)
def main(
registration_config,
target_brain_path,
registration_output_folder,
x_pixel_um=0.02,
y_pixel_um=0.02,
z_pixel_um=0.05,
orientation="coronal",
flip_x=False,
flip_y=False,
flip_z=False,
rotation="x0y0z0",
affine_n_steps=6,
affine_use_n_steps=5,
freeform_n_steps=6,
freeform_use_n_steps=4,
bending_energy_weight=0.95,
grid_spacing=-10,
smoothing_sigma_reference=-1.0,
smoothing_sigma_floating=-1.0,
histogram_n_bins_floating=128,
histogram_n_bins_reference=128,
n_free_cpus=2,
sort_input_file=False,
save_downsampled=True,
additional_images_downsample=None,
boundaries=True,
debug=False,
):
"""
The main function that will perform the library calls and
register the atlas to the brain given on the CLI
:param registration_config:
:param target_brain_path:
:param registration_output_folder:
:param filtered_brain_path:
:param x_pixel_um:
:param y_pixel_um:
:param z_pixel_um:
:param orientation:
:param flip_x:
:param flip_y:
:param flip_z:
:param n_free_cpus:
:param sort_input_file:
:param save_downsampled:
:param additional_images_downsample: dict of
{image_name: image_to_be_downsampled}
:return:
"""
n_processes = get_num_processes(min_free_cpu_cores=n_free_cpus)
load_parallel = n_processes > 1
paths = Paths(registration_output_folder)
atlas = RegistrationAtlas(registration_config,
dest_folder=Path(registration_output_folder))
run = Run(paths, atlas, boundaries=boundaries, debug=debug)
if run.preprocess:
logging.info("Preprocessing data for registration")
logging.info("Loading data")
brain = BrainProcessor(
atlas.pix_sizes,
target_brain_path,
registration_output_folder,
x_pixel_um,
y_pixel_um,
z_pixel_um,
original_orientation=orientation,
load_parallel=load_parallel,
sort_input_file=sort_input_file,
n_free_cpus=n_free_cpus,
)
for element in ["atlas", "brain", "hemispheres"]:
key = f"{element}_name"
logging.debug(f"Transforming atlas file: {element}")
nii_img = atlas.get_nii_from_element(key)
data = np.asanyarray(nii_img.dataobj)
logging.debug("Reorienting to sample orientation")
data = np.transpose(data,
transpositions[brain.original_orientation])
data = np.swapaxes(data, 0, 1)
logging.debug("Reorientating to nifti orientation")
data = flip_multiple(data, flips[orientation])
logging.debug("Flipping to nifti orientation")
data = flip_multiple(data, [flip_x, flip_y, flip_z])
logging.debug("Rotating to sample orientation")
data = rotate_multiple(data, rotation)
new_img = nb.Nifti1Image(data, nii_img.affine, nii_img.header)
brainio.to_nii(new_img, atlas.get_dest_path(key))
if save_downsampled:
brain.target_brain = brain.target_brain.astype(np.uint16,
copy=False)
logging.info("Saving downsampled image")
brain.save(paths.downsampled_brain_path)
brain.filter()
logging.info("Saving filtered image")
brain.save(paths.tmp__downsampled_filtered)
del brain
if additional_images_downsample:
for name, image in additional_images_downsample.items():
if not check_downsampled(registration_output_folder, name):
save_downsampled_image(
image,
name,
registration_output_folder,
atlas,
x_pixel_um=x_pixel_um,
y_pixel_um=y_pixel_um,
z_pixel_um=z_pixel_um,
orientation=orientation,
n_free_cpus=n_free_cpus,
sort_input_file=sort_input_file,
load_parallel=load_parallel,
)
else:
logging.info(f"Image: {name} already downsampled, skipping.")
if run.register:
logging.info("Registering")
if any([
run.affine,
run.freeform,
run.segment,
run.hemispheres,
run.inverse_transform,
]):
registration_params = RegistrationParams(
registration_config,
affine_n_steps=affine_n_steps,
affine_use_n_steps=affine_use_n_steps,
freeform_n_steps=freeform_n_steps,
freeform_use_n_steps=freeform_use_n_steps,
bending_energy_weight=bending_energy_weight,
grid_spacing=grid_spacing,
smoothing_sigma_reference=smoothing_sigma_reference,
smoothing_sigma_floating=smoothing_sigma_floating,
histogram_n_bins_floating=histogram_n_bins_floating,
histogram_n_bins_reference=histogram_n_bins_reference,
)
brain_reg = BrainRegistration(
registration_config,
paths,
registration_params,
n_processes=n_processes,
)
if run.affine:
logging.info("Starting affine registration")
brain_reg.register_affine()
if run.freeform:
logging.info("Starting freeform registration")
brain_reg.register_freeform()
if run.segment:
logging.info("Starting segmentation")
brain_reg.segment()
if run.hemispheres:
logging.info("Segmenting hemispheres")
brain_reg.register_hemispheres()
if run.inverse_transform:
logging.info("Generating inverse (sample to atlas) transforms")
brain_reg.generate_inverse_transforms()
if run.volumes:
logging.info("Calculating volumes of each brain area")
calculate_volumes(
paths.registered_atlas_path,
paths.hemispheres_atlas_path,
atlas.get_element_path("structures_name"),
registration_config,
paths.volume_csv_path,
left_hemisphere_value=int(atlas["left_hemisphere_value"]),
right_hemisphere_value=int(atlas["right_hemisphere_value"]),
)
if run.boundaries:
logging.info("Generating boundary image")
calc_boundaries(
paths.registered_atlas_path,
paths.boundaries_file_path,
atlas_config=registration_config,
)
if run.delete_temp:
logging.info("Removing registration temp files")
delete_temp(paths.registration_output_folder, paths)
logging.info(f"amap completed. Results can be found here: "
f"{registration_output_folder}")
def run(
image,
registration_directory,
preview=False,
volumes=False,
debug=False,
num_colors=10,
brush_size=30,
alpha=0.8,
shading="flat",
):
paths = Paths(registration_directory, image)
registration_directory = Path(registration_directory)
if not paths.tmp__inverse_transformed_image.exists():
transform_image_to_standard_space(
registration_directory,
image_to_transform_fname=image,
output_fname=paths.tmp__inverse_transformed_image,
log_file_path=paths.tmp__inverse_transform_log_path,
error_file_path=paths.tmp__inverse_transform_error_path,
)
else:
print("Registered image exists, skipping")
registered_image = prepare_load_nii(paths.tmp__inverse_transformed_image)
print("\nLoading manual segmentation GUI.\n ")
print("Please 'colour in' the regions you would like to segment. \n "
"When you are done, press Ctrl+S to save and exit. \n If you have "
"used the '--preview' flag, \n the region will be shown in 3D in "
"brainrender\n for you to inspect.")
with napari.gui_qt():
viewer = napari.Viewer(title="Manual segmentation")
display_channel(
viewer,
registration_directory,
paths.tmp__inverse_transformed_image,
)
global label_layers
label_layers = []
label_files = glob(str(paths.regions_directory) + "/*.nii")
if paths.regions_directory.exists() and label_files != []:
label_layers = []
for label_file in label_files:
label_layers.append(
add_existing_label_layers(viewer, label_file))
else:
label_layers.append(
add_new_label_layer(
viewer,
registered_image,
brush_size=brush_size,
num_colors=num_colors,
))
@viewer.bind_key("Control-N")
def add_region(viewer):
print("\nAdding new region")
label_layers.append(
add_new_label_layer(
viewer,
registered_image,
name="new_region",
brush_size=brush_size,
num_colors=num_colors,
))
@viewer.bind_key("Control-X")
def close_viewer(viewer):
print("\nClosing viewer")
QApplication.closeAllWindows()
@viewer.bind_key("Control-S")
def save_analyse_regions(viewer):
ensure_directory_exists(paths.regions_directory)
delete_directory_contents(str(paths.regions_directory))
if volumes:
annotations = load_any(paths.annotations)
hemispheres = load_any(paths.hemispheres)
structures_reference_df = load_structures_as_df(
get_structures_path())
print(
f"\nSaving summary volumes to: {paths.regions_directory}")
for label_layer in label_layers:
analyse_region_brain_areas(
label_layer,
paths.regions_directory,
annotations,
hemispheres,
structures_reference_df,
)
print(f"\nSaving regions to: {paths.regions_directory}")
for label_layer in label_layers:
save_regions_to_file(
label_layer,
paths.regions_directory,
paths.downsampled_image,
)
close_viewer(viewer)
if not debug:
print("Deleting temporary files")
delete_temp(paths.registration_output_folder, paths)
obj_files = glob(str(paths.regions_directory) + "/*.obj")
if obj_files:
if preview:
print("\nPreviewing in brainrender")
load_regions_into_brainrender(obj_files,
alpha=alpha,
shading=shading)
else:
print("\n'--preview' selected, but no regions to display")
def main(
registration_config,
target_brain_path,
registration_output_folder,
x_pixel_um=0.02,
y_pixel_um=0.02,
z_pixel_um=0.05,
orientation="coronal",
flip_x=False,
flip_y=False,
flip_z=False,
affine_n_steps=6,
affine_use_n_steps=5,
freeform_n_steps=6,
freeform_use_n_steps=4,
bending_energy_weight=0.95,
grid_spacing=-10,
smoothing_sigma_reference=-1.0,
smoothing_sigma_floating=-1.0,
histogram_n_bins_floating=128,
histogram_n_bins_reference=128,
n_free_cpus=2,
sort_input_file=False,
save_downsampled=True,
additional_images_downsample=None,
boundaries=True,
debug=False,
):
"""
The main function that will perform the library calls and
register the atlas to the brain given on the CLI
:param registration_config:
:param target_brain_path:
:param registration_output_folder:
:param filtered_brain_path:
:param x_pixel_um:
:param y_pixel_um:
:param z_pixel_um:
:param orientation:
:param flip_x:
:param flip_y:
:param flip_z:
:param n_free_cpus:
:param sort_input_file:
:param save_downsampled:
:param additional_images_downsample: dict of
{image_name: image_to_be_downsampled}
:return:
"""
n_processes = get_num_processes(min_free_cpu_cores=n_free_cpus)
load_parallel = n_processes > 1
paths = Paths(registration_output_folder)
atlas = Atlas(registration_config, dest_folder=registration_output_folder)
run = Run(paths, atlas, boundaries=boundaries, debug=debug)
if run.preprocess:
logging.info("Preprocessing data for registration")
logging.info("Loading data")
brain = BrainProcessor(
atlas,
target_brain_path,
registration_output_folder,
x_pixel_um,
y_pixel_um,
z_pixel_um,
original_orientation=orientation,
load_parallel=load_parallel,
sort_input_file=sort_input_file,
n_free_cpus=n_free_cpus,
)
# reorients the atlas to the orientation of the sample
brain.swap_atlas_orientation_to_self()
# reorients atlas to the nifti (origin is the most ventral, posterior,
# left voxel) coordinate framework
flip = flips[orientation]
brain.flip_atlas(flip)
# flips if the input data doesnt match the nifti standard
brain.flip_atlas((flip_x, flip_y, flip_z))
brain.atlas.save_all()
if save_downsampled:
brain.target_brain = brain.target_brain.astype(
np.uint16, copy=False
)
logging.info("Saving downsampled image")
brain.save(paths.downsampled_brain_path)
brain.filter()
logging.info("Saving filtered image")
brain.save(paths.tmp__downsampled_filtered)
del brain
if additional_images_downsample:
for name, image in additional_images_downsample.items():
if not check_downsampled(registration_output_folder, name):
save_downsampled_image(
image,
name,
registration_output_folder,
atlas,
x_pixel_um=x_pixel_um,
y_pixel_um=y_pixel_um,
z_pixel_um=z_pixel_um,
orientation=orientation,
n_free_cpus=n_free_cpus,
sort_input_file=sort_input_file,
load_parallel=load_parallel,
)
else:
logging.info(f"Image: {name} already downsampled, skipping.")
if run.register:
logging.info("Registering")
if any(
[
run.affine,
run.freeform,
run.segment,
run.hemispheres,
run.inverse_transform,
]
):
registration_params = RegistrationParams(
registration_config,
affine_n_steps=affine_n_steps,
affine_use_n_steps=affine_use_n_steps,
freeform_n_steps=freeform_n_steps,
freeform_use_n_steps=freeform_use_n_steps,
bending_energy_weight=bending_energy_weight,
grid_spacing=grid_spacing,
smoothing_sigma_reference=smoothing_sigma_reference,
smoothing_sigma_floating=smoothing_sigma_floating,
histogram_n_bins_floating=histogram_n_bins_floating,
histogram_n_bins_reference=histogram_n_bins_reference,
)
brain_reg = BrainRegistration(
registration_config,
paths,
registration_params,
n_processes=n_processes,
)
if run.affine:
logging.info("Starting affine registration")
brain_reg.register_affine()
if run.freeform:
logging.info("Starting freeform registration")
brain_reg.register_freeform()
if run.segment:
logging.info("Starting segmentation")
brain_reg.segment()
if run.hemispheres:
logging.info("Segmenting hemispheres")
brain_reg.register_hemispheres()
if run.inverse_transform:
logging.info("Generating inverse (sample to atlas) transforms")
brain_reg.generate_inverse_transforms()
if run.volumes:
logging.info("Calculating volumes of each brain area")
calculate_volumes(
paths.registered_atlas_path,
paths.hemispheres_atlas_path,
atlas.get_structures_path(),
registration_config,
paths.volume_csv_path,
left_hemisphere_value=atlas.get_left_hemisphere_value(),
right_hemisphere_value=atlas.get_right_hemisphere_value(),
)
if run.boundaries:
logging.info("Generating boundary image")
calc_boundaries(
paths.registered_atlas_path,
paths.boundaries_file_path,
atlas_config=registration_config,
)
if run.delete_temp:
logging.info("Removing registration temp files")
delete_temp(paths.registration_output_folder, paths)
logging.info(
f"amap completed. Results can be found here: "
f"{registration_output_folder}"
)