def __relative_intensity(self):
logger.info('computing relative intensity')
print('computing relative intensity')
if self._t1file != None and self._t2file != None:
t1_n4_gm = self._t1_n4 * self._t1_n4.new_image_like(self._gm)
t1_n4_wm = self._t1_n4 * self._t1_n4.new_image_like(self._wm)
bg_t1 = peakfinder(t1_n4_gm, t1_n4_wm, 1, 99.5)
t1_ri = compute_RI(self._t1_n4.numpy(), bg_t1, self._mask.numpy())
tmp = self._t1_n4.new_image_like(t1_ri)
self._ri = ants.smooth_image(tmp, sigma=3, FWHM=True)
ants.image_write(
self._ri,
os.path.join(self._outputdir,
self._id + '_t1_relative_intensity.nii.gz'))
if self._t1file != None and self._t2file == None:
t1_n4_gm = self._t1_n4 * self._t1_n4.new_image_like(self._gm)
t1_n4_wm = self._t1_n4 * self._t1_n4.new_image_like(self._wm)
bg_t1 = peakfinder(t1_n4_gm, t1_n4_wm, 1, 99.5)
t1_ri = compute_RI(self._t1_n4.numpy(), bg_t1, self._mask.numpy())
tmp = self._t1_n4.new_image_like(t1_ri)
self._ri = ants.smooth_image(tmp, sigma=3, FWHM=True)
ants.image_write(
self._ri,
os.path.join(self._outputdir,
self._id + '_t1_relative_intensity.nii.gz'))
def Save_Images_Transformed(nameSubject, ImageToSave, isT1, *cont):
#cwd = Path.cwd()
#Sacamos nuestra ruta actual
mod_path = Path(__file__).parent
#A través de una ruta relativa buscamos la carpeta de almacenamiento de datos.
pathOfData = str((mod_path / str("../Datos")))
#Si data working no existe lo creamos
if not (os.path.exists(str(pathOfData + "/DataWorking"))):
os.mkdir(str(pathOfData + "/DataWorking"))
pathOfData2 = str((mod_path / str("../Datos/DataWorking")))
#Si el sujeto no ha sido todavía creado, lo creamos (La carpeta)
if not (os.path.exists(str(pathOfData2 + "/" + nameSubject))):
os.mkdir(str(pathOfData2 + "/" + nameSubject))
#Si es la imagen transformada...
if (isT1):
#Creamos la ruta de donde guardarlo
savePath = (mod_path /
str("../Datos/DataWorking/" + nameSubject + "/" +
nameSubject + "_t1.nii.gz")).resolve()
#Lo guardamos, se hace el casteo para evitar errores con pathlib
ants.image_write(ImageToSave, str(savePath))
#Si no es la imagen, es la mascara de la lesión.
else:
savePath = (
mod_path /
str("../Datos/DataWorking/" + nameSubject + "/" + nameSubject +
"_lesson[" + str(cont[0]) + "].nii.gz")).resolve()
ants.image_write(ImageToSave, str(savePath))
def crop(self, img_dir, label_dir):
img_pix = ants.image_read(img_dir)
img = img_pix.numpy()
label_pix = ants.image_read(label_dir)
label = label_pix.numpy()
# label_nib = nib.load('Label/N001_Q_QSM_SyNAggro_moved_ROIs.nii.gz')
# np_data = np.array(label_nib.dataobj)
# # print(np.where(np_data>3))
label_bounding_box_0 = np.where(label > 0) # label =1 to 10
label_bounding_box_11 = np.where(label < 11)
print(label_bounding_box_11)
x_min = np.min(label_bounding_box_0[0])
y_min = np.min(label_bounding_box_0[1])
z_min = np.min(label_bounding_box_0[2])
x_max = np.max(label_bounding_box_0[0])
y_max = np.max(label_bounding_box_0[1])
z_max = np.max(label_bounding_box_0[2])
print(x_min, y_min, z_min, x_max, y_max, z_max, img_dir)
cropped_label = ants.crop_indices(label_pix, (x_min, y_min, z_min),
(x_max, y_max, z_max))
# cropped = ants.crop_image(img,label,3)
cropped_img = ants.crop_indices(img_pix, (x_min, y_min, z_min),
(x_max, y_max, z_max))
if not os.path.exists("data/QSM_masked_cropped/"):
os.makedirs("data/QSM_masked_cropped/")
if not os.path.exists("data/label_cropped/"):
os.makedirs("data/label_cropped/")
img_name = re.split(r'[/.]', img_dir)[2]
label_name = re.split(r'[/.]', label_dir)[2]
ants.image_write(
cropped_img,
"data/QSM_masked_cropped/" + img_name + "_cropped.nii.gz")
ants.image_write(
cropped_label,
"data/label_cropped/" + label_name + "_cropped.nii.gz")
def add_3dvolume(self, volume, tag, global_step=None, walltime=None):
filename = tag + "_"
if global_step is None:
filename += datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
else:
filename += str(global_step)
if isinstance(volume, torch.Tensor):
volume = volume.detach().cpu().numpy()
img = ants.from_numpy(volume)
ants.image_write(img, os.path.join(self._log_dir,
filename + ".nii.gz"))
plugin_data = tf.SummaryMetadata.PluginData(
plugin_name="tb_3d_volume_plugin",
content=TextPluginData(version=0).SerializeToString())
metadata = tf.SummaryMetadata(plugin_data=plugin_data)
tensor = TensorProto(
dtype='DT_STRING',
string_val=[filename.encode(encoding='utf_8')],
tensor_shape=TensorShapeProto(dim=[TensorShapeProto.Dim(size=1)]))
summary = summary_pb2.Summary(value=[
summary_pb2.Summary.Value(
tag=tag, metadata=metadata, tensor=tensor)
])
self._file_writer.add_summary(summary,
global_step=global_step,
walltime=walltime)
self._file_writer.flush()
def robex(img, out_mask, skull_stripped=False):
"""
perform skull-stripping on the registered image using the
ROBEX algorithm
Args:
img (str): path to image to skull strip
out_mask (str): path to output mask file
skull_stripped (bool): return the mask
AND the skull-stripped image [default = False]
Returns:
mask (ants.ANTsImage): mask/skull-stripped image
"""
with warnings.catch_warnings():
warnings.filterwarnings('ignore')
_ = ROBEX.robex(img, outfile=out_mask)
skull_stripped_img = ants.image_read(out_mask)
mask = skull_stripped_img.get_mask(low_thresh=1)
ants.image_write(mask, out_mask)
if skull_stripped:
# write the skull-stripped image to disk if desired (in addition to mask)
dirname, base, _ = split_filename(out_mask)
base = base.replace(
'mask', 'stripped') if 'mask' in base else base + '_stripped'
ants.image_write(skull_stripped_img,
os.path.join(dirname, base + '.nii.gz'))
return mask
def reg(fix_path,fix_label_path,move_path,move_label_path,type='SyN'):
#读取数据，格式为： ants.core.ants_image.ANTsImage
fix_img = ants.image_read(fix_path)
fix_label_img = ants.image_read(fix_label_path)
move_img = ants.image_read(move_path)
move_label_img = ants.image_read(move_label_path)
g1 = ants.iMath_grad( fix_img )
g2 = ants.iMath_grad( move_img )
demonsMetric = ['demons', g1, g2, 1, 1]
ccMetric = ['CC', fix_img, move_img, 2, 4 ]
metrics = list( )
metrics.append( demonsMetric )
#配准
# outs = ants.registration(fix_img,move_img,type_of_transforme = 'Affine')
# outs = ants.registration( fix_img, move_img, 'ElasticSyN', multivariate_extras = metrics )
outs = ants.registration( fix_img, move_img, type)
#获取配准后的数据，并保存
reg_img = outs['warpedmovout']
save_path = './warp_image.nii.gz'
ants.image_write(reg_img,save_path)
#获取move到fix的转换矩阵；将其应用到 move_label上；插值方式选取 最近邻插值; 这个时候也对应的将label变换到 配准后的move图像上
reg_label_img = ants.apply_transforms(fix_img ,move_label_img,transformlist= outs['fwdtransforms'],interpolator = 'nearestNeighbor')
save_label_path = './warp_label.nii.gz'
ants.image_write(reg_label_img,save_label_path)
return dice_compute(reg_label_img.numpy().astype(np.int32),fix_label_img.numpy().astype(np.int32),indexes=[5])
def identifyLeads(self, fileID, CTimaging, threshold, areas):
"""Estimate number of electrodes found using regionprops routine and generate a PointCloud for every lead.
Details can be found in the book chapter by Husch et al (2015)"""
detected_leads = []
pca = PCA()
for i, comp in enumerate(areas):
X = np.multiply(comp.coords, np.tile(list(CTimaging.spacing), (len(comp.coords), 1)))
n_samples = X.shape[0]
X_transformed = pca.fit_transform(X)
X_centered = X - np.mean(X, axis=0)
cov_matrix = np.dot(X_centered.T, X_centered) / n_samples
latent = pca.explained_variance_
if self.debug: # sanity check
for latent_test, eigenvector in zip(latent, pca.components_):
print(np.dot(eigenvector.T, np.dot(cov_matrix, eigenvector)))
if len(latent) < 3:
continue
latent = np.sqrt(latent) * 2
lowerAxesLength = sorted(latent[1:3])
if (latent[0] >
float(cfg['lead_detection']['PaCER']['lambda']) and latent[0] / np.mean(latent[1:3]) > 10
and lowerAxesLength[1] / (lowerAxesLength[0] + .001) < 8):
detected_leads.append(comp)
if not detected_leads:
while threshold < 3000:
print("Trying a higher threshold to ensure leads are detected.")
leadpoint_cloudstruct = self.electrodeEstimation(fileID, threshold * 1.2)
return leadpoint_cloudstruct
else:
raise Exception("\t\tEven w/ thresholds around 3000 HU, no leads were detected. Double-check input!")
# TODO include transformation matrix from file if selected in options
transformation_matrix = np.multiply(np.eye(3), [round(f, 1) for f in
CTimaging.spacing]) # transformation only necessary if selected in options; otherwise all remains in "AN space"
leadpoint_cloudstruct = [] # initialise variable in workspace
items = ['pixelList', 'elecMask', 'points', 'pixelValues']
CTimagingData = CTimaging.numpy() # get the shape of CT imaging to later fill it with content
for i, leadID in enumerate(detected_leads):
leadpoint_cloudstruct.append({k: [] for k in items})
pixelList = leadID['coords']
leadpoint_cloudstruct[i]['pixelList'] = pixelList
leadpoint_cloudstruct[i]['points'] = pixelList @ abs(transformation_matrix[:3, :3])
leadpoint_cloudstruct[i]['pixelValues'] = np.array([CTimagingData[tuple(pixelList[i])]
for i, k in enumerate(pixelList)])
elecMask_temp = np.zeros(shape=CTimaging.shape)
for x, y, z in pixelList:
elecMask_temp[x, y, z] = 1
leadpoint_cloudstruct[i]['elecMask'] = elecMask_temp
filename_elecMask = os.path.join(os.path.split(fileID[0])[0], 'elecMask_no' + str(i) + '.nii')
ants.image_write(image=CTimaging.new_image_like(elecMask_temp), filename=filename_elecMask) # mask to NIFTI
return leadpoint_cloudstruct, transformation_matrix
def save_mask_of_targetpic(self, pic_dir):
if not os.path.exists("data/mask/"):
os.makedirs("data/mask/")
file_name = re.split(r'[/.]', pic_dir)[-3]
image = ants.image_read(pic_dir)
mask = image.clone()
mask[mask != 0] = 1
ants.image_write(mask, "data/mask/mask_of_" + file_name + ".nii.gz")
def tract2standard(t_fn, t1_fn, fixed_fn, trans_type='SyNRA'):
print(f'registration using ANTs {trans_type}...')
fixed = ants.image_read(fixed_fn)
moving = ants.image_read(t1_fn)
# this is a workaround to emulate antsRegistrationSyNQuick.sh.
# Unfortunately it is not possible to equally emulate the script.
# There are differences in terms of parameters (shrink factor and num of
# iterations) in the rigid and in the affine registration
if trans_type == 'SyNRA':
# values taken from https://github.com/ANTsX/ANTs/blob/952e7918b47385ebfb730f9c844977762b8437f8/Scripts/antsRegistrationSyNQuick.sh#L455
# Notes:
# 1. syn_metric and num_of_bins (syn_sampling) are the same as default:
# "mattes" and 32 respectively
# 2. the three values that configure the SyN[x,x,x] optimization are
# respectively grad_step, flow_sigma, and total_sigma
# 3. syn_iterations correspond to reg_iterations
# 4. smoothing sigmas and shrink factor are automatically set inside the
# function. As desired they are set to be: "3x2x1x0vox" and "8x4x2x1"
# respectively
mytx = ants.registration(fixed=fixed,
moving=moving,
type_of_transform=trans_type,
reg_iterations=(100, 70, 50, 0),
grad_step=0.1,
flow_sigma=3,
total_sigma=0)
else:
mytx = ants.registration(fixed=fixed,
moving=moving,
type_of_transform=trans_type)
ants.image_write(mytx['warpedmovout'], f'{tmp_dir}/struct_warped.nii.gz')
print('correcting warp to mrtrix convention...')
os.system(f'warpinit {fixed_fn} {tmp_dir}/ID_warp[].nii.gz -force')
for i in range(3):
temp_warp = ants.image_read(f'{tmp_dir}/ID_warp{i}.nii.gz')
temp_warp = ants.apply_transforms(fixed=moving,
moving=temp_warp,
transformlist=mytx['invtransforms'],
whichtoinvert=[True, False],
defaultvalue=2147483647)
ants.image_write(temp_warp, f'{tmp_dir}/mrtrix_warp{i}.nii.gz')
os.system(f'warpcorrect {tmp_dir}/mrtrix_warp[].nii.gz ' +
f'{tmp_dir}/mrtrix_warp_cor.nii.gz ' +
'-marker 2147483647 -tolerance 0.0001 -force')
print('applaying warp to tractogram...')
t_mni_fn = t_fn[:-4] + '_mni.tck'
os.system(
f'tcktransform {t_fn} {tmp_dir}/mrtrix_warp_cor.nii.gz {t_mni_fn} ' +
'-force -nthreads 0')
return t_mni_fn
def cde_mot_rigidreg(fixed,
images,
Fimg='..',
spacing=list([1.6, 1.6, 8]),
crop=False,
saveprog=False,
savesuff='',
savedir='.'):
import ants
import os
import datetime
import time
print('>> Starting rigid registration <<')
if type(fixed) == str: fi = ants.image_read(Fimg + os.sep + fixed)
else: fi = fixed
if crop: fi = ants.crop_indices(fi, [0, 0, 1], fi.shape)
if savesuff: savesuff = '_' + savesuff
mvd = []
cnt = 0
pct1 = len(images) / 100
for i in images:
cnt = cnt + 1
if type(i) == str: img = ants.image_read(Fimg + os.sep + i)
else: img = i
img.set_spacing(spacing)
if crop: img = ants.crop_indices(img, [0, 0, 1], img.shape)
fi.set_spacing(spacing)
# Actual ants registration step
#-----------------------------------------------------------------------
moved = ants.registration(fi, img, type_of_transform='QuickRigid')
if saveprog:
savename = savedir + os.sep + str(cnt).zfill(4) + savesuff + '.tif'
ants.image_write(moved["warpedmovout"], savename)
mvd.append(savename)
else:
mvd.append(moved["warpedmovout"])
if cnt / pct1 % 5 == 0: # < this doesn't work robustly
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime(
'%Y-%m-%d %H:%M:%S')
print('Completed ' + str((cnt) / pct1) + '% at ' + st)
print('All done with rigid registration')
if saveprog: print('The returned file contains tifs')
return mvd
def runeachsess(subj,ses):
targ = os.path.join(derivatives,"sub-"+subj,"ses-"+ses,"anat") # find path to anat folder for this subject and this session
fpaths = glob.glob(targ+"/*T2w.nii.gz") # find the T1
fpaths = ''.join(fpaths)
if len(fpaths) > 0:
img = ants.image_read(fpaths)
mask = ants.get_mask(img)
dn = ants.denoise_image(img,mask,noise_model='Rician')
ants.image_write(dn,fpaths[0:-7]+'_dn.nii.gz',)
def average_images():
"""Return the average of all images in list"""
combined_image = ants.image_read("../DeformReg/DeformReg-1-50.nii.gz")
for i in range(2, 22):
image_name = "../DeformReg/DeformReg-" + str(i) + "-50.nii.gz"
combined_image += ants.image_read(image_name)
combined_image /= 21
ants.image_write("ants_average_template.nii.gz")
def create_brainmask(input_folder, subj, registered_images):
"""this function import antspynet in order to obtain a probabilistic brain mask for the T1 imaging"""
import ants, antspynet
filename_brainmask = os.path.join(input_folder, 'brainmask_T1.nii')
brainmask = antspynet.brain_extraction(image=registered_images,
verbose=False)
ants.image_write(image=brainmask, filename=filename_brainmask)
return (filename_brainmask, subj)
def process_MSD(root, task='Heart2', num_surf=5):
img_list, gt_list = get_MSD_list(root, task)
save_dir = os.path.join(root, task)
n = len(img_list)
for i in range(n):
print('Process img: {}'.format(img_list[i]))
img = ants.image_read(img_list[i])
gt = ants.image_read(gt_list[i])
# iso-resample
img_ = iso_resample(img, [1.5, 1.5, 1.5], islabel=False)
gt_ = iso_resample(gt, [1.5, 1.5, 1.5], islabel=True)
# crop
img_np = img_.numpy()
gt_np = gt_.numpy()
img_np = crop(img_np)
gt_np = crop(gt_np)
# normal
img_np = normalize(img_np)
# sample surf init
for j in tqdm(range(num_surf)):
gt_dfm = elasticdeform.deform_random_grid(gt_np, 4, 4, 0)
gt_dfm_smooth = mcubes.smooth_gaussian(gt_dfm, 1)
v, e = mcubes.marching_cubes(gt_dfm_smooth, 0)
mcubes.export_obj(
v, e,
os.path.join(
save_dir, 'surfs_unaligned',
'{:0>2d}_{:0>2d}surf_init.obj'.format(i + 1, j + 1)))
# write image
img_nii = ants.from_numpy(img_np, img_.origin, img_.spacing,
img_.direction, img_.has_components,
img_.is_rgb)
gt_nii = ants.from_numpy(gt_np, gt_.origin, gt_.spacing, gt_.direction,
gt_.has_components, gt_.is_rgb)
ants.image_write(
img_nii,
os.path.join(save_dir, 'images', '{:0>2d}img.nii'.format(i + 1)))
ants.image_write(
gt_nii,
os.path.join(save_dir, 'labels', '{:0>2d}gt.nii'.format(i + 1)))
gt_smooth = mcubes.smooth_gaussian(gt_np, 1)
v, e = mcubes.marching_cubes(gt_smooth, 0)
mcubes.export_obj(
v, e,
os.path.join(save_dir, 'surfs_unaligned',
'{:0>2d}surf.obj'.format(i + 1)))
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 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 crop_onpic(self, img_dir, label_dir, lowerind, upperind, path):
img_pix = ants.image_read(img_dir)
label_pix = ants.image_read(label_dir)
cropped_img = ants.crop_indices(img_pix, lowerind, upperind)
cropped_label = ants.crop_indices(label_pix, lowerind, upperind)
img_name = re.split(r'[/.]', img_dir)[-3]
label_name = re.split(r'[/.]', label_dir)[-3]
ants.image_write(
cropped_img,
path + "QSM_masked_cropped/" + img_name + "_cropped.nii.gz")
ants.image_write(
cropped_label,
path + "label_cropped/" + label_name + "_cropped.nii.gz")
def evaluate_test_subject(scan_path: str, scan_name: str, options: dict,
model):
# Read the image to analize:
scan = ants.image_read(os.path.join(scan_path, scan_name + ".nii.gz"))
scan_np = scan.numpy()
# define the torch.device
device = torch.device('cuda') if options['gpu_use'] else torch.device(
'cpu')
# Create the patches of the image to evaluate
infer_patches, coordenates = get_inference_patches(
scan_path=scan_path,
input_data=[scan_name + "_norm.nii.gz"],
roi=scan_name + "_ROI.nii.gz",
patch_shape=options['patch_size'],
step=options['sampling_step'],
normalize=options['normalize'])
# Get the shape of the patches
sh = infer_patches.shape
segmentation_pred = np.zeros((sh[0], 4, sh[2], sh[3], sh[4]))
batch_size = options['batch_size']
# model Evaluation
model.eval()
b = 0
with torch.no_grad():
for b in range(0, len(segmentation_pred), batch_size):
x = torch.tensor(infer_patches[b:b + batch_size]).to(device)
pred = model(x)
# save the result back from GPU to CPU --> numpy
segmentation_pred[b:b + batch_size] = pred.cpu().numpy()
# reconstruct image takes the inferred patches, the patches coordenates and the image size as inputs
all_probs = np.zeros(scan_np.shape + (4, ))
for i in range(4):
all_probs[:, :, :, i] = reconstruct_image(segmentation_pred[:, i],
coordenates, scan.shape)
segmented = np.argmax(all_probs, axis=3).astype(np.uint8)
# Create a nifti image
segm_img = ants.from_numpy(segmented)
segm_img = ants.copy_image_info(scan, segm_img)
# Save the segmentation mask
output_name = os.path.join(scan_path, scan_name + '_result.nii.gz')
ants.image_write(segm_img, output_name)
return segm_img
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 __bias_correction(self):
logger.info("performing N4 bias correction")
print("performing N4 bias correction")
if self._t1file != None and self._t2file != None:
self._t1_n4 = ants.iMath(
self._t1_reg['warpedmovout'].abp_n4(usen3=self._usen3),
"Normalize") * 100
self._t2_n4 = ants.iMath(self._t2_reg.abp_n4(usen3=self._usen3),
"Normalize") * 100
ants.image_write(
self._t1_n4,
os.path.join(self._outputdir, self._id + '_t1_final.nii.gz'))
ants.image_write(
self._t2_n4,
os.path.join(self._outputdir, self._id + '_t2_final.nii.gz'))
if self._t1file != None and self._t2file == None:
self._t1_n4 = ants.iMath(
self._t1_reg['warpedmovout'].abp_n4(usen3=self._usen3),
"Normalize") * 100
ants.image_write(
self._t1_n4,
os.path.join(self._outputdir, self._id + '_t1_final.nii.gz'))
if self._t2file != None and self._t1file == None:
self._t2_n4 = ants.iMath(
self._t2_reg['warpedmovout'].abp_n4(usen3=self._usen3),
"Normalize") * 100
ants.image_write(
self._t2_n4,
os.path.join(self._outputdir, self._id + '_t2_final.nii.gz'))
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 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 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 apply_to_images(self,
fn,
modality,
image_type=None,
subjects='*',
out_suffix=''):
for subject in self.subjects:
in_file = self.get_modality(subject=subject, modality=modality)
img = ants.image_read(in_file)
img_proc = fn(img)
out_file = in_file.replace('.nii.gz', '%s.nii.gz' % out_suffix)
ants.image_write(img_proc, out_file)
def pyAntsApp(reg, fixed_image, moving_image, output_filename):
# moving_image = ants.image_read(moving_image)
# fixed_image = ants.image_read(fixed_image)
fixed_image = imread(fixed_image)
moving_image = imread(moving_image)
fixed_image = ants.from_numpy(fixed_image)
moving_image = ants.from_numpy(moving_image)
warped_moving_image = ants.apply_transforms(fixed=fixed_image, moving=moving_image, transformlist=reg['fwdtransforms'])
# warped_moving_image.plot()
# cv2.waitKey()
assert output_filename.endswith('.npy')
ants.image_write(warped_moving_image, output_filename)
warped_moving_image_numpy = warped_moving_image.numpy()
imsave(output_filename.replace('.npy', '.tif'), warped_moving_image_numpy)
def main(args=None):
args = arg_parser().parse_args(args)
if args.verbosity == 1:
level = logging.getLevelName('INFO')
elif args.verbosity >= 2:
level = logging.getLevelName('DEBUG')
else:
level = logging.getLevelName('WARNING')
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=level)
logger = logging.getLogger(__name__)
try:
img_fns = glob_nii(args.img_dir)
if not os.path.exists(args.output_dir):
logger.info('Making Output Directory: {}'.format(args.output_dir))
os.mkdir(args.output_dir)
if args.template_dir is None:
logger.info('Registering image to MNI template')
template = ants.image_read(ants.get_ants_data('mni')).reorient_image2(args.orientation)
orientation = args.orientation
else:
template_fns = glob_nii(args.template_dir)
if len(template_fns) != len(img_fns):
raise NormalizationError('If template images are provided, they must be in '
'correspondence (i.e., equal number) with the source images')
for i, img in enumerate(img_fns):
_, base, _ = split_filename(img)
logger.info('Registering image to template: {} ({:d}/{:d})'.format(base, i+1, len(img_fns)))
if args.template_dir is not None:
template = ants.image_read(template_fns[i])
orientation = template.orientation if hasattr(template, 'orientation') else None
input_img = ants.image_read(img)
input_img = input_img.reorient_image2(orientation) if orientation is not None else input_img
if not args.no_rigid:
logger.info('Starting rigid registration: {} ({:d}/{:d})'.format(base, i+1, len(img_fns)))
mytx = ants.registration(fixed=template, moving=input_img, type_of_transform="Rigid")
tx = mytx['fwdtransforms'][0]
else:
tx = None
logger.info('Starting {} registration: {} ({:d}/{:d})'.format(args.registration, base, i+1, len(img_fns)))
mytx = ants.registration(fixed=template, moving=input_img, initial_transform=tx, type_of_transform=args.registration)
logger.debug(mytx)
moved = ants.apply_transforms(template, input_img, mytx['fwdtransforms'], interpolator='bSpline')
registered = os.path.join(args.output_dir, base + '_reg.nii.gz')
ants.image_write(moved, registered)
return 0
except Exception as e:
logger.exception(e)
return 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 __gradient_magnitude(self):
logger.info("computing gradient magnitude")
print("computing gradient magnitude")
if self._t1file != None and self._t2file != None:
self._grad_t1 = ants.iMath(self._t1_n4, "Grad", 1)
# self._grad_t2 = ants.iMath(self._t2_n4, "Grad", 1)
ants.image_write(
self._grad_t1,
os.path.join(self._outputdir,
self._id + '_t1_gradient_magnitude.nii.gz'))
# ants.image_write( self._grad_t1, os.path.join(self._outputdir, self._id+'_t2_gradient_magnitude.nii.gz'))
if self._t1file != None and self._t2file == None:
self._grad_t1 = ants.iMath(self._t1_n4, "Grad", 1)
ants.image_write(
self._grad_t1,
os.path.join(self._outputdir,
self._id + '_t1_gradient_magnitude.nii.gz'))
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 )
numberOfOuterIterations = 5
image = ants.image_read( dataDirectory + 'KKI2009-01-MPRAGE_slice150.nii.gz', dimension = 2 )
mask = ants.image_read( dataDirectory + 'KKI2009-01-MPRAGE_slice150_mask.nii.gz', dimension = 2 )
weightMask = None
for i in range( numberOfOuterIterations ):
print( "*************** N4 <---> Atropos iteration ", i, " ******************\n" )
n4Results = ants.n4_bias_field_correction( image, mask = mask,
weight_mask = weightMask, verbose = True )
image = n4Results
atroposResults = ants.atropos( a = image, x = mask )
onesImage = ants.make_image( image.shape, voxval = 0,
spacing = ants.get_spacing( image ),
origin = ants.get_origin( image ),
direction = ants.get_direction( image ) )
weightMask = atroposResults['probabilityimages'][1] *\
( onesImage - atroposResults['probabilityimages'][0] ) *\
( onesImage - atroposResults['probabilityimages'][2] ) +\
atroposResults['probabilityimages'][2] *\
( onesImage - atroposResults['probabilityimages'][1] ) *\
( onesImage - atroposResults['probabilityimages'][0] )
ants.image_write( image, outputPrefix + "N4Corrected.nii.gz" )
ants.image_write( atroposResults['segmentation'], outputPrefix + "AtroposSegmentation.nii.gz" )
for i in range( len( atroposResults['probabilityimages'] ) ):
ants.image_write( atroposResults['probabilityimages'][i],
outputPrefix + "AtroposSegmentationProbability" + str( i ) + ".nii.gz" )
