def main(inputpath: str):
tmpdir = "/tmp"
# ventricledistmap = sitk.ReadImage("ventricle_distancemap.nii.gz")
ventricledistpath = "/media/yannick/c4a7e8d3-9ac5-463f-b6e6-92e216ae6ac0/BRATS/BraTS2020/ventricle_distancemap.nii.gz"
atlaspath = "/media/yannick/c4a7e8d3-9ac5-463f-b6e6-92e216ae6ac0/BRATS/BraTS2020/MNI152_T1_1mm_brain.nii.gz"
t1suffix = "_t1.nii.gz"
# get patient directories
patdirs = [elem for elem in os.listdir(inputpath) if os.path.isdir(os.path.join(inputpath, elem))]
ventricledistmap = ants.image_read(ventricledistpath)
skippedlist = []
for patdir in tqdm(patdirs):
currpatdir = os.path.join(inputpath, patdir)
t1_patfile = os.path.join(currpatdir, patdir + t1suffix)
try:
fi = ants.image_read(t1_patfile)
mi = ants.image_read(atlaspath)
tx = ants.registration(fixed=fi, moving=mi, type_of_transform='SyN', verbose=True)
ventrdist_t1space = ants.apply_transforms(fi, ventricledistmap, tx["fwdtransforms"], interpolator='linear', imagetype=0,
whichtoinvert=None, compose=None, verbose=False)
# save transform and warped images to output folder
shutil.copy(tx["fwdtransforms"][1], os.path.join(currpatdir, "Atlas_to_t1.mat"))
shutil.copy(tx["invtransforms"][0], os.path.join(currpatdir, "T1_to_atlas.mat"))
ants.image_write(tx["warpedmovout"], os.path.join(currpatdir, "Atlas_t1space.nii.gz"))
ants.image_write(tx["warpedfixout"], os.path.join(currpatdir, "T1_atlasspace.nii.gz"))
ants.image_write(ventrdist_t1space, os.path.join(currpatdir, "ventricledistmap_t1space.nii.gz"))
# delete temporary *.nii.gz and *.mat files
try:
niftitmp = glob(os.path.join(tmpdir, "*.nii.gz"))
mattmp = glob(os.path.join(tmpdir, "*.mat"))
[os.remove(elem) for elem in niftitmp]
[os.remove(elem) for elem in mattmp]
except:
pass
except:
skippedlist.append(patdir)
print("Skipped " + str(patdir))
continue
print("###### COMPLETED ######")
print("Skipped cases:")
print(skippedlist)
def _run_coregistration(self):
img_reference = ants.image_read(self.dict_img[self.reference], reorient=True)
# Register the reference to MNI, if needed
if self.mni:
print(f"[INFO] Registering to 1x1x1mm MNI space using ANTsPy")
print(f"{self.reference} is used as reference")
img_mni = ants.image_read(self.mni_path, reorient=True)
reg = ants.registration(img_mni, img_reference, "Affine")
img_reference = reg["warpedmovout"]
self._save_scan(img_reference, f"{self.prefix}{self.reference}", self.coregistration_folder)
reg_tomni = reg["fwdtransforms"]
if not self.label is None:
img_label = ants.image_read(self.label, reorient=True)
warped_label = ants.apply_transforms(img_mni, img_label, reg_tomni, interpolator="nearestNeighbor")
self._save_scan(warped_label, f"{self.prefix}Label", self.coregistration_folder)
else:
self._save_scan(img_reference, f"{self.prefix}{self.reference}", self.coregistration_folder)
if not self.label is None:
img_label = ants.image_read(self.label, reorient=True)
self._save_scan(img_label, f"{self.prefix}Label", self.coregistration_folder)
# Register the other scans, if needed
modalities_toregister = list(self.modalities)
modalities_toregister.remove(self.reference)
for mod in modalities_toregister:
if self.already_coregistered:
if self.mni: # if the scans are already co-registered we reuse the ref to MNI transformation
img_mod = ants.image_read(self.dict_img[mod], reorient=True)
warped_img = ants.apply_transforms(img_mni, img_mod, reg_tomni, interpolator="linear")
self._save_scan(warped_img, f"{self.prefix}{mod}", self.coregistration_folder)
print(f"[INFO] Registration performed to MNI for {mod}")
else:
img_mod = ants.image_read(self.dict_img[mod], reorient=True)
self._save_scan(img_mod, f"{self.prefix}{mod}", self.coregistration_folder)
print(f"No co-registration performed for {mod}")
else: # Scans are not co-registered
img_mod = ants.image_read(self.dict_img[mod], reorient=True)
reg = ants.registration(img_reference, img_mod, "Affine")
self._save_scan(reg["warpedmovout"], f"{self.prefix}{mod}", self.coregistration_folder)
print(f"[INFO] Registration using ANTsPy for {mod} with {self.reference} as reference")
def test_registration_types(self):
print("Starting long registration interface test")
fi = ants.image_read(ants.get_ants_data("r16"))
mi = ants.image_read(ants.get_ants_data("r64"))
fi = ants.resample_image(fi, (60, 60), 1, 0)
mi = ants.resample_image(mi, (60, 60), 1, 0)
for ttype in self.transform_types:
print(ttype)
mytx = ants.registration(fixed=fi,
moving=mi,
type_of_transform=ttype)
# with mask
fimask = fi > fi.mean()
mytx = ants.registration(fixed=fi,
moving=mi,
mask=fimask,
type_of_transform=ttype)
print("Finished long registration interface test")
def align_volume(fixed, moving, vol):
moving_vol = ants.from_numpy(moving[:, :, :, vol])
with stderr_redirected(
): # to prevent dumb itk gaussian error bullshit infinite printing
motCorr_vol = ants.registration(fixed,
moving_vol,
type_of_transform='SyN')
return motCorr_vol
def get_zshift(fixed, moving):
fixed_ants = to_ants(fixed)
moving_ants = to_ants(moving)
res = ants.registration(fixed_ants, moving_ants,
type_of_transform='Translation',
grad_step=.2)
t = ants.read_transform(res['fwdtransforms'][0])
zshift_float = t.parameters[-1]
zshift = int(round(zshift_float))
return zshift
def affine_registration():
"""Affinely register each image to the fixed image (21)"""
fixed_image = ants.image_read("../KKI2009-ALL-MPRAGE/KKI2009-21-MPRAGE.nii.gz")
for i in range(1, 21):
moving_image = ants.image_read("../KKI2009-ALL-MPRAGE/KKI2009-" + str(i) + "-MPRAGE.nii.gz")
after_reg = ants.registration(fixed=fixed_image,
moving=moving_image,
type_of_transform='Affine',
aff_metric='meansquares')
ants.image_write(after_reg["warpedmovout"],
"../AffineReg/AntsAffineReg-" + str(i) + "-to-21.nii.gz")
def test_example(self):
fi = ants.image_read(ants.get_ants_data('r16'))
mi = ants.image_read(ants.get_ants_data('r64'))
mygr = ants.create_warped_grid(mi)
mytx = ants.registration(fixed=fi,
moving=mi,
type_of_transform=('SyN'))
mywarpedgrid = ants.create_warped_grid(mi,
grid_directions=(False, True),
transform=mytx['fwdtransforms'],
fixed_reference_image=fi)
def __init__(self,
image_fixed='path',
atlas_template_moved='path',
atlas_label_moved='path',
output_template_name='path',
output_label_name='path',
interpolator="enumerate(('linear',\
'nearestNeighbor',\
'multiLabel',\
'genericlabel',\
'gaussian',\
'bSpline',\
'cosineWindowedSinc',\
'welchWindowedSinc',\
'hammingWindowedSinc',\
'lanczosWindowedSinc'))",
transform="enumerate(('Translation',\
'Rigid',\
'Similarity',\
'QuickRigid',\
'DenseRigid',\
'BOLDRigid',\
'Affine',\
'AffineFast',\
'BOLDAffine',\
'TRSAA',\
'ElasticSyN',\
'SyN',\
'SyNRA',\
'SyNOnly',\
'SyNCC',\
'SyNabp',\
'SyNBold',\
'SyNBoldAff',\
'SyNAggro',\
'TVMSQ',\
'TVMSQC'))"):
import ants
img_fi = ants.image_read(image_fixed)
atlas_temp_mo = ants.image_read(atlas_template_moved)
atlas_lab_mo = ants.image_read(atlas_label_moved)
warpedmoveout = ants.registration(fixed=img_fi,
moving=atlas_temp_mo,
type_of_transform=transform)
imagetransformed = ants.apply_transforms(
fixed=warpedmoveout['warpedmovout'],
moving=atlas_lab_mo,
transformlist=warpedmoveout['fwdtransforms'],
interpolator=interpolator)
ants.image_write(warpedmoveout['warpedmovout'], output_template_name)
ants.image_write(imagetransformed, output_label_name)
self.temp_reg = output_template_name
self.lab_reg = output_label_name
def __register_to_MNI_space(self):
logger.info("registration to MNI template space")
print("registration to MNI template space")
if self._t1file != None and self._t2file != None:
self._t1_reg = ants.registration(fixed=self._icbm152,
moving=self._t1,
type_of_transform='Affine')
self._t2_reg = ants.apply_transforms(
fixed=self._icbm152,
moving=self._t2,
transformlist=self._t1_reg['fwdtransforms'])
if self._t1file != None and self._t2file == None:
self._t1_reg = ants.registration(fixed=self._icbm152,
moving=self._t1,
type_of_transform='Affine')
if self._t2file != None and self._t1file == None:
self._t2_reg = ants.registration(fixed=self._icbm152,
moving=self._t2,
type_of_transform='Affine')
def registration(reference, image, segmentation):
import ants
reference_as_ants = ants.from_numpy(reference)
image_as_ants = ants.from_numpy(image)
output = ants.registration(reference_as_ants, image_as_ants)
registered_image = output.get("warpedmovout")
segmentation_as_ants = ants.from_numpy(segmentation)
registered_segmentation = ants.apply_transforms(
reference_as_ants, segmentation_as_ants, output.get("fwdtransforms"))
registered_segmentation = registered_segmentation.numpy()
registered_segmentation[registered_segmentation > 0] = 1
return registered_image.numpy(), registered_segmentation
def _run_coregistration(self):
print("[INFO] Performing Coregistration using ANTsPy")
print(f"{self.reference} is used as reference")
img_reference = ants.image_read(self.dict_img[self.reference],
reorient=True)
if self.mni:
print("[INFO] Registering to 1x1x1mm MNI space")
img_mni = ants.image_read(self.mni_path, reorient=True)
reg = ants.registration(img_mni, img_reference, 'Affine')
img_reference = reg['warpedmovout']
self._save_scan(img_reference, self.reference,
self.coregistration_folder)
modalities_toregister = list(self.dict_img.keys())
modalities_toregister.remove(self.reference)
for mod in modalities_toregister:
img_mod = ants.image_read(self.dict_img[mod], reorient=True)
reg = ants.registration(img_reference, img_mod, 'Affine')
self._save_scan(reg['warpedmovout'], mod,
self.coregistration_folder)
print(f"Registration performed for {mod}")
def alignData(fixedImage,
movingImage,
resultDirectory=None,
type_of_transform='SyNRA',
**kwargs):
"""Align images using elastix, estimates a transformation :math:`T:` fixed image :math:`\\rightarrow` moving image.
Arguments:
fixedImage (str): image source of the fixed image (typically the reference image)
movingImage (str): image source of the moving image (typically the image to be registered)
resultDirectory (str or None): result directory for transform parameters. None saves to bq3ddefault temp file
transform: (str): type of transform to apply as defined in 'ants.registration' type_of_transform
**kwargs: additional arguments to pass to 'ants.registration'
Returns:
str: path to elastix result directory
"""
log_parameters(fixedImage=fixedImage,
movingImage=movingImage,
resultDirectory=resultDirectory,
type_of_transform=type_of_transform)
# setup input
mi = ants.from_numpy(io.readData(movingImage).astype('float32'))
fi = ants.from_numpy(io.readData(fixedImage).astype('float32'))
# setup output directory
if not resultDirectory:
tmp_folder = os.path.join(config.temp_dir, 'ANTs')
resultDirectory = tmp_folder
resultDirectory = resultDirectory + '/' if not resultDirectory.endswith(
'/') else resultDirectory #make sure ends with '/'
os.makedirs(resultDirectory, exist_ok=True)
# run
result = ants.registration(fi,
mi,
type_of_transform=type_of_transform,
outprefix=resultDirectory,
verbose=True,
**kwargs)
# save output
io.writeData(os.path.join(resultDirectory, 'result.tif'),
result['warpedmovout'].numpy())
# cleanup#
if not resultDirectory:
shutil.rmtree(tmp_folder)
return resultDirectory
def test_example(self):
fi = ants.image_read(ants.get_ants_data("r16"))
mi = ants.image_read(ants.get_ants_data("r64"))
fi = ants.resample_image(fi, (128, 128), 1, 0)
mi = ants.resample_image(mi, (128, 128), 1, 0)
mytx = ants.registration(fixed=fi,
moving=mi,
type_of_transform=("SyN"))
try:
jac = ants.create_jacobian_determinant_image(
fi, mytx["fwdtransforms"][0], 1)
except:
pass
def align_anat(fixed_path, moving_path, save_dir, type_of_transform,
resolution, mirror):
### Load fixed brain
fixed = load_numpy_brain(fixed_path)
fixed = ants.from_numpy(fixed)
fixed.set_spacing(resolution)
### Load moving brain
moving = load_numpy_brain(moving_path)
if mirror:
moving = moving[::-1, :, :]
moving = ants.from_numpy(moving)
moving.set_spacing(resolution)
### Align
with stderr_redirected(
): # to prevent itk gaussian error infinite printing
if type_of_transform == 'SyN':
moco = ants.registration(fixed,
moving,
type_of_transform=type_of_transform,
flow_sigma=5,
total_sigma=5)
else:
moco = ants.registration(fixed,
moving,
type_of_transform=type_of_transform)
### Save
fixed_fly = fixed_path.split('/')[-1].split('.')[0]
moving_fly = moving_path.split('/')[-1].split('.')[0]
if mirror:
save_file = os.path.join(save_dir,
moving_fly + '_m' + '-to-' + fixed_fly)
else:
save_file = os.path.join(save_dir, moving_fly + '-to-' + fixed_fly)
save_file += '.nii'
nib.Nifti1Image(moco['warpedmovout'].numpy(),
np.eye(4)).to_filename(save_file)
def main(inputpath: str, outdir: str):
tmpdir = "/tmp"
ventricledistmap = sitk.ReadImage("/media/yannick/MANAGE/BraTS20/ventricle_distancemap.nii.gz")
# create output directory, if it does not already exist
if not os.path.isdir(outdir):
os.makedirs(outdir, exist_ok=True)
# get patient directories
patdirs = [elem for elem in os.listdir(inputpath) if os.path.isdir(os.path.join(inputpath, elem))]
skippedlist = []
for patdir in tqdm(patdirs):
currpatdir = os.path.join(inputpath, patdir)
caseid = ('_').join([patdir, tp])
t1_patfile = os.path.join(currpatdir, "T1_r2s_bet-biascorr.nii.gz")
if not os.path.isfile(t1_patfile) or os.path.isfile(os.path.join(outdir, caseid + "_t1_atlasspace.nii.gz")):
print("Skipped " + str(caseid))
continue
else:
fi = ants.image_read(t1_patfile)
mi = ants.image_read(atlaspath)
try:
tx = ants.registration(fixed=fi, moving=mi, type_of_transform='SyN', verbose=False)
# save transform and warped images to output folder
shutil.copy(tx["fwdtransforms"][1], os.path.join(outdir, caseid + "_atlas_to_t1.mat"))
shutil.copy(tx["invtransforms"][0], os.path.join(outdir, caseid + "_t1_to_atlas.mat"))
ants.image_write(tx["warpedmovout"], os.path.join(outdir, caseid + "_atlas_t1space.nii.gz"))
ants.image_write(tx["warpedfixout"], os.path.join(outdir, caseid + "_t1_atlasspace.nii.gz"))
# delete temporary *.nii.gz and *.mat files
try:
niftitmp = glob(os.path.join(tmpdir, "*.nii.gz"))
mattmp = glob(os.path.join(tmpdir, "*.mat"))
[os.remove(elem) for elem in niftitmp]
[os.remove(elem) for elem in mattmp]
except:
pass
except:
skippedlist.append(caseid)
print("Skipped " + str(caseid))
continue
def rigid_registration(threet, sevent, mask, fname):
"""
:param threeT: String path Input file for 3T
:param sevenT: String path Input file for 7T
:param fname: String path 7T to 3T registered image
return none
"""
fixed_image = ants.image_read(threet)
moving_image = ants.image_read(sevent)
transform = ants.registration(fixed_image,moving_image,\
'Rigid',mask=mask,verbose=True)
rigid_img = ants.apply_transforms(fixed_image, moving_image,
transform['fwdtransforms'])
ants.image_write(rigid_img, fname)
def affine_registration(threet, sevent, fname):
"""
:param threeT: String path Input file for 3T
:param sevenT: String path Input file for 7T
:param fname: String path 7T to 3T registered image
return none
"""
fixed_image = ants.image_read(threet)
moving_image = ants.image_read(sevent)
transform = ants.registration(fixed_image,moving_image,\
'Affine',aff_metric='meansquares')
affine_img = ants.apply_transforms(fixed_image, moving_image,
transform['fwdtransforms'])
ants.image_write(affine_img, fname)
def deformable_registration(indir,aff_template,outdir):
"""
"""
fixed_image = ants.image_read(aff_template)
for subdir,directory,files in os.walk(indir):
for i,fname in enumerate(files):
file = subdir+'/'+fname
print(file)
moving_image = ants.image_read(file)
transform = ants.registration(fixed_image,moving_image,\
'SyNOnly',reg_iterations=(60,40,0))
reg_img = ants.apply_transforms(fixed_image,moving_image,transform['fwdtransforms'])
ants.image_write(reg_img,outdir+'/'+fname)
def deformable_registration(threet,sevent,fname):
"""
:param threeT: String path Input file for 3T
:param sevenT: String path Input file for 7T
:param fname: String path 7T to 3T registered image
return none
"""
fixed_image = ants.image_read(threet)
moving_image = ants.image_read(sevent)
transform = ants.registration(fixed_image,moving_image,\
'SyNOnly',reg_iterations=(60,40,0))
reg_img = ants.apply_transforms(fixed_image,moving_image,transform['fwdtransforms'])
ants.image_write(reg_img,fname)
def warp(self, masked_dir_list, label_dir_list, target_num):
basicTool = basic()
basicTool.mkdir('data/fusion_label_multi/QSM_warped')
basicTool.mkdir('data/fusion_label_multi/label_warped')
# target img
testsubject_img = ants.image_read(masked_dir_list[target_num])
testsubject_label = ants.image_read(label_dir_list[target_num])
target_file_name = re.split(r'[/.]', masked_dir_list[target_num])[-3]
target_label_name = re.split(r'[/.]', label_dir_list[target_num])[-3]
ants.image_write(
testsubject_img, 'data/fusion_label_multi/QSM_warped/' +
target_file_name + '_warped.nii.gz')
ants.image_write(
testsubject_label, 'data/fusion_label_multi/label_warped/' +
target_label_name + '_warped.nii.gz')
# del target img
del masked_dir_list[target_num]
del label_dir_list[target_num]
print(masked_dir_list, label_dir_list)
# 读取文件, 24个atlas
for i in range(24):
move_img = ants.image_read(masked_dir_list[i]) # subject的图像
# 配准，使用SyN
outs = ants.registration(testsubject_img,
move_img,
type_of_transforme='SyN')
atlas_name = re.split(r'[/.]', masked_dir_list[i])[-3]
print(atlas_name, ' has been warped')
# atlas的label_img
atlas_label_img = ants.image_read(label_dir_list[i]) # atlas的标签图像
# 模板标签warp到图像,move_img是要配准到的空间即（fix），label_img是要应用变化的图像（move），transformlist是move到fix的转换矩阵，genericLabel用于多标签的插值
warped_atlas_label_img = ants.apply_transforms(
fixed=testsubject_img,
moving=atlas_label_img,
transformlist=outs['fwdtransforms'],
interpolator='nearestNeighbor') # 'genericLabel'
# get file name( without .nii.gz)
label_name = re.split(r'[/.]', label_dir_list[i])[-3]
print(label_name, 'has been warped')
# 保存变换后的图像
warped_atlas_filename = 'data/fusion_label_multi/QSM_warped/' + atlas_name + '_warped.nii.gz'
warped_atlas_label_filename = 'data/fusion_label_multi/label_warped/' + label_name + '_warped_label.nii.gz'
ants.image_write(warped_atlas_label_img,
warped_atlas_label_filename)
ants.image_write(outs['warpedmovout'], warped_atlas_filename)
def registration(reference, image, segmentation):
import ants
reference_as_ants = ants.from_numpy(reference)
image_as_ants = ants.from_numpy(image)
#Rigid, Affine, Similarity, SyN
output = ants.registration(reference_as_ants,
image_as_ants,
type_of_transform='SyN')
registered_image = output.get("warpedmovout")
segmentation_as_ants = ants.from_numpy(segmentation)
registered_segmentation = ants.apply_transforms(
reference_as_ants, segmentation_as_ants, output.get("fwdtransforms"))
registered_segmentation = registered_segmentation.numpy()
registered_segmentation[registered_segmentation > 0] = 1
return registered_image.numpy(), registered_segmentation
def transform_rois(fixed, moving, rois, **kwargs):
def set_ifn(key, val):
if not key in kwargs:
kwargs[key] = val
set_ifn('type_of_transform', 'Affine')
set_ifn('reg_iterations', [500, 500, 500])
set_ifn('grad_step', .1)
res = ants.registration(fixed, moving, **kwargs)
t = ants.read_transform(res['fwdtransforms'][0])
xyzs = rois[:, :3]
rs = rois[:, 3:]
xyzs_transformed = np.array(list(map(lambda xyz: transform_xyz(t.invert(), xyz, moving, fixed), xyzs)))
return np.concatenate([xyzs_transformed, rs], axis=1)
def affine_registration(indir,outdir):
"""
"""
for subdir,directory,files in os.walk(indir):
for i,fname in enumerate(files):
file = subdir+'/'+fname
print(file)
if(i==0):
fixed_image = ants.image_read(file)
else:
moving_image = ants.image_read(file)
transform = ants.registration(fixed_image,moving_image,\
'Affine',aff_metric='meansquares')
affine_img = ants.apply_transforms(fixed_image,moving_image,transform['fwdtransforms'])
ants.image_write(affine_img,outdir+'/'+fname)
def deformable_registration():
"""Deformably register each image to the fixed image (21) with Demons algo"""
fixed_image = ants.image_read("../AffineReg/ants-affine-template.nii.gz")
iterations = [25, 50]
for iteration in iterations:
for i in range(1, 21):
moving_image = ants.image_read("../AffineReg/AntsAffineReg-" +
str(i) + "-to21.nii.gzz")
after_reg = ants.registration(fixed=fixed_image,
moving=moving_image,
type_of_transform='SyN',
aff_metric='meansquares',
syn_metric='demons',
reg_iterations=[iteration])
ants.image_write(
after_reg["warpedmovout"], "../DeformReg/AntsDeformReg-" +
str(i) + "-" + str(iteration) + ".nii.gz")
def antspy_regi(fixed,
moving,
drift_corr,
metric='mattes',
reg_iterations=(40, 20, 0),
aff_iterations=(2100, 1200, 1200, 10),
aff_shrink_factors=(6, 4, 2, 1),
aff_smoothing_sigmas=(3, 2, 1, 0),
grad_step=0.2,
flow_sigma=3,
total_sigma=0,
aff_sampling=32,
syn_sampling=32):
"""claculate drift of image from ref using Antspy with provided drift_corr"""
try:
fixed = ants.from_numpy(np.float32(fixed))
except:
pass
try:
moving = ants.from_numpy(np.float32(moving))
except:
pass
shift = ants.registration(
fixed,
moving,
type_of_transform=drift_corr,
aff_metric=metric,
syn_metric=metric,
reg_iterations=(reg_iterations[0], reg_iterations[1],
reg_iterations[2]),
aff_iterations=(aff_iterations[0], aff_iterations[1],
aff_iterations[2], aff_iterations[3]),
aff_shrink_factors=(aff_shrink_factors[0], aff_shrink_factors[1],
aff_shrink_factors[2], aff_shrink_factors[3]),
aff_smoothing_sigmas=(aff_smoothing_sigmas[0], aff_smoothing_sigmas[1],
aff_smoothing_sigmas[2],
aff_smoothing_sigmas[3]),
grad_step=grad_step,
flow_sigma=flow_sigma,
total_sigma=total_sigma,
aff_sampling=aff_sampling,
syn_sampling=syn_sampling)
print(shift['fwdtransforms'])
return shift
def test_example(self):
# test ANTsPy/ANTsR example
fixed = ants.image_read( ants.get_ants_data('r16') )
moving = ants.image_read( ants.get_ants_data('r64') )
fixed = ants.resample_image(fixed, (64,64), 1, 0)
moving = ants.resample_image(moving, (64,64), 1, 0)
mytx = ants.registration(fixed=fixed , moving=moving, type_of_transform='SyN' )
mywarpedimage = ants.apply_transforms(fixed=fixed, moving=moving,
transformlist=mytx['fwdtransforms'] )
# bad interpolator
with self.assertRaises(Exception):
mywarpedimage = ants.apply_transforms(fixed=fixed, moving=moving,
transformlist=mytx['fwdtransforms'], interpolator='unsupported-interp' )
# transform doesnt exist
with self.assertRaises(Exception):
mywarpedimage = ants.apply_transforms(fixed=fixed, moving=moving,
transformlist=['blah-blah.mat'], interpolator='unsupported-interp' )
def register3D():
start = time.time()
# Register a good image pair as standrad.
# The paths are for cropped .tiff OCT images & .tiff LS imgae.
fix_path = '/home/ruijiao/A_research/registration/embryo_DAPI/MK_3D/OCT_Cropped/142.png'
move_path = '/home/ruijiao/A_research/registration/embryo_DAPI/MK_3D/MPE_Refocused_3/142.png'
# save_path = join(TIFF_PATH, 'std.tif')
fix_ants = ants.image_read(fix_path)
move_ants = ants.image_read(move_path)
outs = ants.registration(fix_ants, move_ants, type_of_transform='SyN')
# std_img = ants.apply_transforms(fix_ants, move_ants, transformlist = outs['fwdtransforms'], interpolator = 'linear')
# ants.image_write(std_img, save_path)
stop1 = time.time()
print("registration time: " + str(stop1 - start) + " s.")
for i_MPE in os.listdir(MPE_PATH):
# Set images path.
img_Name = i_MPE
i_OCT = img_Name
save_path = join(REG_TIF_PATH, 'registered' + img_Name[0:-4] + '.tiff')
move_img = ants.image_read(join(MPE_PATH, i_MPE))
fix_img = ants.image_read(join(OCT_PATH, i_OCT))
# Apply transformation field "outs" to each image pair.
reg_img = ants.apply_transforms(fix_img,
move_img,
transformlist=outs['fwdtransforms'],
interpolator='linear')
# Set the direction, origin, spacing of registered image the same as fixed images.
reg_img.set_origin(fix_img.origin)
reg_img.set_spacing(fix_img.spacing)
reg_img.set_direction(fix_img.direction)
# Save registered image as .tiff.
ants.image_write(reg_img, save_path)
stop = time.time()
print("Applying transformation field to all images time: " +
str(stop - stop1) + " s.")
def compute_registration_python(self, moving, fixed, registration_method):
moving_ants = ants.image_read(moving, dimension=3)
fixed_ants = ants.image_read(fixed, dimension=3)
try:
# @FIXME: "antsRegistrationSyNQuick[s]" does not work across all platforms, so I temporarily swapped with "SyN".
# Read docs for supported transforms: https://antspy.readthedocs.io/en/latest/_modules/ants/registration/interface.html
self.reg_transform = ants.registration(fixed_ants, moving_ants,
'SyN')
warped_input = ants.apply_transforms(
fixed=fixed_ants,
moving=moving_ants,
transformlist=self.reg_transform['fwdtransforms'],
interpolator='linear',
whichtoinvert=[False, False])
warped_input_filename = os.path.join(self.registration_folder,
'input_volume_to_MNI.nii.gz')
ants.image_write(warped_input, warped_input_filename)
except Exception as e:
print('Exception caught during registration. Error message: {}'.
format(e))
def test_ants():
# fixed = ants.image_read( ants.get_ants_data('r16') ).resample_image((64,64),1,0)
fixed = ants.image_read("/home1/quanquan/datasets/LPBA40/fixed.nii.gz")
print("-------------")
# moving = ants.image_read( ants.get_ants_data('r64') ).resample_image((64,64),1,0)
names = np.array([
x.path for x in os.scandir("/home1/quanquan/datasets/LPBA40/train")
if x.name.endswith("nii.gz")
])
name = names[0]
print("name: ", name)
moving = ants.image_read(name)
# fixed.plot(overlay=moving, title='Before Registration')
mytx = ants.registration(
fixed=fixed, moving=moving,
type_of_transform='Affine') # type_of_transform='SyN'
print(mytx)
warped_moving = mytx['warpedmovout']
# fixed.plot(overlay=warped_moving,
# title='After Registration')
mywarpedimage = ants.apply_transforms(fixed=fixed,
moving=moving,
transformlist=mytx['fwdtransforms'])
# fixed.plot(filename="mywarpedimage.nii.gz")
im = mywarpedimage.numpy()
im = im.transpose((2, 1, 0))
print(im.shape)
print(mytx['fwdtransforms'])
# import ipdb; ipdb.set_trace()
annots = loadmat(mytx['fwdtransforms'][0])
writer = sitk.ImageFileWriter()
writer.SetFileName("mywarpedimage.nii.gz")
writer.Execute(sitk.GetImageFromArray(im))
import ipdb
ipdb.set_trace()
def Transform_Image(imagePath):
#Necesario para que el relative path funcione de manera correcta,
my_path = os.path.abspath(os.path.dirname(__file__))
#Utilizamos la plantilla MANI152
templatePath = os.path.join(my_path, "../Datos/MNI152.nii.gz")
#Cargamos el path que recibe por parametro, si el path da erroneo, ha de cambiarse en el código de Busqueda.
path = os.path.join(my_path, imagePath)
#Leemos los paths y los transformamos en imagenes
template = ants.image_read(templatePath)
image = ants.image_read(path)
#Reesamblamos
template = ants.resample_image(template, (64, 64, 64), 1, 0)
image = ants.resample_image(image, (64, 64, 64), 1, 0)
#Realizamos la transformación
mytx = ants.registration(fixed=template,
moving=image,
type_of_transform='SyN')
mywarpedimage = ants.apply_transforms(fixed=template,
moving=image,
transformlist=mytx['fwdtransforms'])
return mywarpedimage, mytx
fixedImageFile = dataDirectory + 'chalf.nii.gz' fixedImage = ants.image_read( fixedImageFile, dimension = 2 ) movingImageFile = dataDirectory + 'c.nii.gz' movingImage = ants.image_read( movingImageFile, dimension = 2 ) # Plot the fixed and moving images ants.plot( movingImage, overlay = fixedImage, overlay_cmap = "viridis", alpha = 0.9 ) ####### # # Perform registration # outputDirectory = './OutputANTsPy/' if not os.path.isdir( outputDirectory ): os.mkdir( outputDirectory ) outputPrefix = outputDirectory + 'antsr' registration = ants.registration( fixed = fixedImage, moving = movingImage, type_of_transform = 'TVMSQC', grad_step = 2.0, verbose = True, outprefix = outputPrefix ) ants.image_write( registration['warpedmovout'], outputPrefix + "Warped.nii.gz" ) ants.image_write( registration['warpedfixout'], outputPrefix + "InverseWarped.nii.gz" ) # Plot the moving and warped fixed image ants.plot( movingImage, overlay = registration['warpedfixout'], overlay_cmap = "viridis", alpha = 0.9 )
