def eddy_correction(file_in, outPath, ref_bo):
"""
Prueba documental.
In:
file_in: akakakakka
outPath: kakakasjdjdlllf kklkd
ref_bo. kskskdejien skkd dllkd
Out:
"""
print(' - running Eddy Correction...')
refNameOnly = utils.to_extract_filename(file_in)
if not (os.path.exists(outPath + utils.to_extract_filename(file_in) +
d.id_eddy_correct + d.extension)):
refName = utils.to_extract_filename_extention(file_in)
os.system('cp ' + file_in + ' ' + d.path_temporal
) # Copiamos archivo de difusion a la carpeta temporal
fsl.eddy_correct(
d.path_temporal + refName,
d.path_temporal + refNameOnly + d.id_eddy_correct + '.nii', ref_bo)
os.system(
'cp ' + d.path_temporal + refNameOnly + d.id_eddy_correct +
d.extension + ' ' +
outPath) # Copiamos archivo de difusion desde carpeta temporal
return outPath + refNameOnly + d.id_eddy_correct + d.extension
def medianOtsu(file_in, outPath, median_radius=4, num_pass=4):
print(' - running Median Otsu algoritm...')
finalFileName = outPath + utils.to_extract_filename(
file_in) + d.id_median_otsu + '_maskedVolume' + d.extension
binaryMaskFileName = outPath + utils.to_extract_filename(
file_in) + d.id_median_otsu + '_binaryMask' + d.extension
b0MaskedFileName = outPath + utils.to_extract_filename(
file_in) + d.id_median_otsu + '_b0Masked' + d.extension
if not (os.path.exists(finalFileName)):
img = nib.load(file_in)
data = img.get_data()
maskedvolume, mask = median_otsu(data, median_radius, num_pass)
nib.save(nib.Nifti1Image(maskedvolume.astype(np.float32), img.affine),
finalFileName)
nib.save(nib.Nifti1Image(mask.astype(np.float32), img.affine),
binaryMaskFileName)
nib.save(
nib.Nifti1Image(
maskedvolume[:, :, :, d.default_b0_ref].astype(np.float32),
img.affine), b0MaskedFileName)
return finalFileName, binaryMaskFileName
def registration_to(path_moving, path_static, path_output):
moving_img = nib.load(path_moving)
moving_data = moving_img.get_data()
moving_affine = moving_img.affine
img_static = nib.load(path_static)
static_data = img_static.get_data()
static_affine = img_static.affine
affine, starting_affine = tools.affine_registration(
moving_data,
static_data,
moving_grid2world=moving_affine,
static_grid2world=static_affine)
warped_moving, mapping = tools.syn_registration(
moving_data,
static_data,
moving_grid2world=moving_affine,
static_grid2world=static_affine,
# step_length=0.1,
# sigma_diff=2.0,
metric='CC',
dim=3,
level_iters=[5, 5, 3],
# dim=3, level_iters = [10, 10, 5],
# prealign=affine.affine)
prealign=starting_affine)
ref_name = utils.to_extract_filename(path_moving)
nib.save(nib.Nifti1Image(warped_moving.astype(np.float32), static_affine),
path_output + ref_name + '_BET_normalized.nii')
return warped_moving, static_affine, mapping
def to_estimate_dti(file_in, file_inMask, outPath, fbval, fbvec):
print(d.separador + 'building DTI Model...')
ref_name = utils.to_extract_filename(file_in)
if (
not (os.path.exists(outPath + ref_name + d.id_evecs + d.extension))
) | (not (os.path.exists(outPath + ref_name + d.id_evals + d.extension))):
try:
os.remove(outPath + ref_name + d.id_evecs + d.extension)
os.remove(outPath + ref_name + d.id_evals + d.extension)
except:
print("Unexpected error:", sys.exc_info()[0])
img = nib.load(file_in)
data = img.get_data()
mask = nib.load(file_inMask)
mask = mask.get_data()
bvals, bvecs = read_bvals_bvecs(fbval, fbvec)
gtab = gradient_table(bvals, bvecs)
tensor_model = dti.TensorModel(gtab)
tensor_fitted = tensor_model.fit(data, mask)
nib.save(
nib.Nifti1Image(tensor_fitted.evecs.astype(np.float32),
img.affine),
outPath + ref_name + d.id_evecs + d.extension)
nib.save(
nib.Nifti1Image(tensor_fitted.evals.astype(np.float32),
img.affine),
outPath + ref_name + d.id_evals + d.extension)
return outPath + ref_name + d.id_evecs + d.extension, outPath + ref_name + d.id_evals + d.extension
def to_register_dwi_to_mni(path_in, path_out, path_bvec, path_bval):
ref_name = utils.to_extract_filename(path_in)
# if not os.path.exists(path_out + ref_name + '_normalized' + d.extension):
img_DWI = nib.load(path_in)
data_DWI = img_DWI.get_data()
affine_DWI = img_DWI.affine
bvals, bvecs = read_bvals_bvecs(path_bval, path_bvec)
gtab = gradient_table(bvals, bvecs)
b0 = data_DWI[..., gtab.b0s_mask]
mean_b0 = np.mean(b0, -1)
mni_t2 = nib.load(d.standard_t2)
mni_t2_data = mni_t2.get_data()
MNI_T2_affine = mni_t2.affine
directionWarped = np.zeros((mni_t2_data.shape[0], mni_t2_data.shape[1],
mni_t2_data.shape[2], data_DWI.shape[-1]))
rangos = range(data_DWI.shape[-1])
affine, starting_affine = tools.affine_registration(
mean_b0,
mni_t2_data,
moving_grid2world=affine_DWI,
static_grid2world=MNI_T2_affine)
warped_moving, mapping = tools.syn_registration(
mean_b0,
mni_t2_data,
moving_grid2world=affine_DWI,
static_grid2world=MNI_T2_affine,
# step_length=0.1,
# sigma_diff=2.0,
metric='CC',
dim=3,
level_iters=[10, 10, 5],
# prealign=affine.affine)
prealign=starting_affine)
for gradientDirection in rangos:
# print(gradientDirection)
directionWarped[:, :, :, gradientDirection] = mapping.transform(
data_DWI[:, :, :, gradientDirection].astype(int),
interpolation='nearest')
nib.save(nib.Nifti1Image(directionWarped, MNI_T2_affine),
path_out + ref_name + '_normalized' + d.extension)
return path_out + ref_name + '_normalized' + d.extension, mapping
def betDWI(file_in, outPath):
print(' - running BET with FSL...')
finalFileName = outPath + utils.to_extract_filename(
file_in) + d.id_bet + '_dwi_masked' + d.extension
binaryMaskFileName = outPath + utils.to_extract_filename(
file_in) + d.id_bet + '_b0_masked_mask' + d.extension
b0MaskedFileName = outPath + utils.to_extract_filename(
file_in) + d.id_bet + '_b0_masked' + d.extension
if not (os.path.exists(b0MaskedFileName)):
fsl.bet(file_in, b0MaskedFileName, '-m -f .4')
imgMask = nib.load(binaryMaskFileName)
dataMask = imgMask.get_data()
img = nib.load(file_in)
data = img.get_data()
data[dataMask == 0] = 0
nib.save(nib.Nifti1Image(data.astype(np.float32), img.affine),
finalFileName)
return finalFileName, binaryMaskFileName, b0MaskedFileName
def reslicing(file_in, outPath, vox_sz):
print(' - runnning Reslice...')
finalFileName = outPath + utils.to_extract_filename(
file_in) + d.id_reslice + d.extension
if not (os.path.exists(finalFileName)):
img = nib.load(file_in)
data = img.get_data()
affine = img.affine
old_vox_sz = img.header.get_zooms()[:3]
new_vox_sz = (vox_sz, vox_sz, vox_sz)
# Si el tamano del voxel es isotropico, no es necesario hacer el reslice
data, affine = reslice(data, affine, old_vox_sz, new_vox_sz)
nib.save(nib.Nifti1Image(data, affine), finalFileName)
return finalFileName
def registration_atlas_to(path_atlas, path_output, affine, mapping):
img_atlas = nib.load(path_atlas)
atlas_data = img_atlas.get_data()
indexs = np.unique(atlas_data)
ref_name = utils.to_extract_filename(path_atlas)
list_path_roi = []
for index in indexs:
roi = (atlas_data == index)
# warped_roi = mapping.transform_inverse(roi.astype(int)*255, interpolation='nearest')
warped_roi = mapping.transform_inverse(
ndim.binary_dilation(roi).astype(int), interpolation='nearest')
warped_roi = ndim.binary_dilation(warped_roi)
warped_roi = ndim.binary_erosion(warped_roi)
bin_warped_roi = np.ceil(warped_roi)
filled_warped_roi = ndim.binary_fill_holes(
bin_warped_roi.astype(int)).astype(int)
nib.save(nib.Nifti1Image(filled_warped_roi.astype(np.float32), affine),
path_output + ref_name + '_ROI_' + str(index) + d.extension)
list_path_roi.append(path_output + ref_name + '_ROI_' + str(index) +
d.extension)
# print("ROI # " + str(index) + " for " + ref_name + " Atlas, has been saved")
if not ('registered_atlas' in locals()):
registered_atlas = np.zeros(filled_warped_roi.shape)
registered_atlas[filled_warped_roi != 0] = index
nib.save(nib.Nifti1Image(registered_atlas.astype(np.float32), affine),
path_output + ref_name + '_registered_' + d.extension)
return list_path_roi
def nonLocalMean(file_in, outPath):
print(' - running NonLocal Mean algoritm...')
finalFileName = outPath + utils.to_extract_filename(
file_in) + d.id_non_local_mean + d.extension
if not (os.path.exists(finalFileName)):
img = nib.load(file_in)
data = img.get_data()
newData = np.zeros(data.shape)
gradientDirections = data.shape[-1]
for index in range(gradientDirections):
print(index)
sigma = estimate_sigma(data[:, :, :, index], N=8)
newData[:, :, :, index] = nlmeans(data[:, :, :, index],
sigma=sigma)
nib.save(nib.Nifti1Image(newData.astype(np.float32), img.affine),
finalFileName)
return finalFileName
def registerAffine_atlas(pathAtlas, pathStandard, outPath, tempPath,
affineSubject, Subject):
atlas = nib.load(pathAtlas)
atlas_data = atlas.get_data()
indexs = np.unique(atlas_data)
refNameOnly = utils.to_extract_filename(pathAtlas)
file_outSubject, omatSubject = fsl.flirt(
pathStandard, tempPath + 'Aux_FLIRT' + d.extension, Subject,
tempPath + 'Aux_FLIRT_omat.mat')
fsl.hex_to_dec(omatSubject, omatSubject + '.mat2')
omatSubject = omatSubject + '.mat2'
for index in indexs:
roi = (atlas_data == index)
nib.save(nib.Nifti1Image(roi.astype(np.float32), affineSubject),
tempPath + refNameOnly + '_ROI_' + str(index) + d.extension)
fsl.flirt_xfm(
tempPath + refNameOnly + '_ROI_' + str(index) + d.extension,
outPath + refNameOnly + '_ROI_' + str(index) + '_FLIRT' +
d.extension, Subject, omatSubject)
def to_estimate_dti_maps(path_dwi_input, path_output, file_tensor_fitevecs,
file_tensor_fitevals):
ref_name_only = utils.to_extract_filename(file_tensor_fitevecs)
ref_name_only = ref_name_only[:-9]
list_maps = []
img_tensorFitevecs = nib.load(file_tensor_fitevecs)
img_tensorFitevals = nib.load(file_tensor_fitevals)
evecs = img_tensorFitevecs.get_data()
evals = img_tensorFitevals.get_data()
affine = img_tensorFitevecs.affine
print(d.separador + d.separador + 'computing of FA map')
FA = fractional_anisotropy(evals)
FA[np.isnan(FA)] = 0
nib.save(nib.Nifti1Image(FA.astype(np.float32), affine),
path_output + ref_name_only + '_FA' + d.extension)
list_maps.append(path_output + ref_name_only + '_FA' + d.extension)
print(d.separador + d.separador + 'computing of Color FA map')
FA2 = np.clip(FA, 0, 1)
RGB = color_fa(FA2, evecs)
nib.save(nib.Nifti1Image(np.array(255 * RGB, 'uint8'), affine),
path_output + ref_name_only + '_FA_RGB' + d.extension)
print(d.separador + d.separador + 'computing of MD map')
MD = dti.mean_diffusivity(evals)
nib.save(nib.Nifti1Image(MD.astype(np.float32), affine),
path_output + ref_name_only + '_MD' + d.extension)
list_maps.append(path_output + ref_name_only + '_MD' + d.extension)
print(d.separador + d.separador + 'computing of AD map')
AD = dti.axial_diffusivity(evals)
nib.save(nib.Nifti1Image(AD.astype(np.float32), affine),
path_output + ref_name_only + '_AD' + d.extension)
list_maps.append(path_output + ref_name_only + '_AD' + d.extension)
print(d.separador + d.separador + 'computing of RD map')
RD = dti.radial_diffusivity(evals)
nib.save(nib.Nifti1Image(RD.astype(np.float32), affine),
path_output + ref_name_only + '_RD' + d.extension)
list_maps.append(path_output + ref_name_only + '_RD' + d.extension)
sphere = get_sphere('symmetric724')
peak_indices = quantize_evecs(evecs, sphere.vertices)
eu = EuDX(FA.astype('f8'),
peak_indices,
seeds=300000,
odf_vertices=sphere.vertices,
a_low=0.15)
tensor_streamlines = [streamline for streamline in eu]
hdr = nib.trackvis.empty_header()
hdr['voxel_size'] = nib.load(path_dwi_input).get_header().get_zooms()[:3]
hdr['voxel_order'] = 'LAS'
hdr['dim'] = FA.shape
tensor_streamlines_trk = ((sl, None, None) for sl in tensor_streamlines)
nib.trackvis.write(path_output + ref_name_only + '_tractography_EuDx.trk',
tensor_streamlines_trk,
hdr,
points_space='voxel')
return list_maps
