def convert_dicom_to_nifti(dicom_dir=None, output_dir=None):
try:
if not os.path.exists(dicom_dir):
return (False, 'Dicom dir is NULL')
if dicom_dir.endswith('/'):
dicom_dir = dicom_dir[:-1]
study_id = dicom_dir.split('/')[-2]
serie_id = dicom_dir.split('/')[-1]
if output_dir is None:
output_dir = f'{BASE_NII_ORIGINAL_OUTPUT_DIR}/{study_id}'
if not os.path.exists(output_dir):
os.mkdir(output_dir)
if not os.path.exists(output_dir):
return (False, f'Path {output_dir} does not exist')
output_dir = f'{output_dir}/{serie_id}.nii.gz'
dicom2nifti.dicom_series_to_nifti(dicom_dir,
output_dir,
reorient_nifti=False)
return (True, output_dir)
except Exception as e:
return (False, f'Error: {e}')
def _convert_dicom_to_nifti(original_dicom_directory, output_fpath, verbose=True):
if verbose:
print(f"Reading in dicoms from {original_dicom_directory}")
print(f"Saving to {output_fpath}")
# try to run mrconvert and reorient to `LAS` direction
output_dict = dicom2nifti.dicom_series_to_nifti(
original_dicom_directory, output_fpath, reorient_nifti=False
)
nb_img = output_dict["NII"]
image_input = output_dict["NII_FILE"]
print("Orientation of nifti image: ", nb.aff2axcodes(nb_img.affine))
img = nb.load(image_input)
print("Reoriented image to ", nb.aff2axcodes(img.affine))
return image_input
def convert_data():
if verbose:
print('Sorting the dicom files and converting to nifti')
datasets = [f for f in os.listdir(tmpdir) if not f.startswith('.')]
datasets.sort(key=float)
# Check that correct number of files is present
assert len(os.listdir('%s/%s' % (tmpdir, datasets[0]))) == 128
assert len(os.listdir('%s/%s' % (tmpdir, datasets[1]))) == 128
assert len(os.listdir('%s/%s' % (tmpdir, datasets[2]))) == 132
dicom2nifti.dicom_series_to_nifti('%s/%s' % (tmpdir, datasets[0]),
'%s/opposedphase.nii.gz' % tmpdir,
reorient_nifti=True)
dicom2nifti.dicom_series_to_nifti('%s/%s' % (tmpdir, datasets[1]),
'%s/inphase.nii.gz' % tmpdir,
reorient_nifti=True)
dicom2nifti.dicom_series_to_nifti('%s/%s' % (tmpdir, datasets[2]),
'%s/umap.nii.gz' % tmpdir,
reorient_nifti=True)
import dicom2nifti
original_dicom_directory = 'D:/testdata/images/image_0001'
output_file = 'result.nii'
dicom2nifti.dicom_series_to_nifti(original_dicom_directory,
output_file,
reorient_nifti=True)
def dicom_to_nifti(self):
dicom2nifti.dicom_series_to_nifti(
self.__path_to_dicoms + self.__serie_name__,
self.__path_for_nifti + 'volume-0')
return self.__path_for_nifti + 'volume-0.nii'
def test_main_function(self):
tmp_output_dir = tempfile.mkdtemp()
try:
results = dicom2nifti.dicom_series_to_nifti(test_data.SIEMENS_ANATOMICAL,
os.path.join(tmp_output_dir, 'test.nii.gz'),
False)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.SIEMENS_ANATOMICAL)[0])
results = dicom2nifti.dicom_series_to_nifti(test_data.SIEMENS_ANATOMICAL,
os.path.join(tmp_output_dir, 'test.nii.gz'),
True)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.SIEMENS_ANATOMICAL)[1])
results = dicom2nifti.dicom_series_to_nifti(test_data.SIEMENS_ANATOMICAL_IMPLICIT,
os.path.join(tmp_output_dir, 'test.nii.gz'),
False)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.SIEMENS_ANATOMICAL_IMPLICIT)[0])
results = dicom2nifti.dicom_series_to_nifti(test_data.SIEMENS_ANATOMICAL_IMPLICIT,
os.path.join(tmp_output_dir, 'test.nii.gz'),
True)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.SIEMENS_ANATOMICAL_IMPLICIT)[1])
results = dicom2nifti.dicom_series_to_nifti(test_data.GENERIC_ANATOMICAL,
os.path.join(tmp_output_dir, 'test.nii.gz'),
False)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.GENERIC_ANATOMICAL)[0])
results = dicom2nifti.dicom_series_to_nifti(test_data.GENERIC_ANATOMICAL,
os.path.join(tmp_output_dir, 'test.nii.gz'),
True)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.GENERIC_ANATOMICAL)[1])
results = dicom2nifti.dicom_series_to_nifti(test_data.GENERIC_ANATOMICAL_IMPLICIT,
os.path.join(tmp_output_dir, 'test.nii.gz'),
False)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.GENERIC_ANATOMICAL_IMPLICIT)[0])
results = dicom2nifti.dicom_series_to_nifti(test_data.GENERIC_ANATOMICAL_IMPLICIT,
os.path.join(tmp_output_dir, 'test.nii.gz'),
True)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.GENERIC_ANATOMICAL_IMPLICIT)[1])
results = dicom2nifti.dicom_series_to_nifti(test_data.GENERIC_COMPRESSED,
os.path.join(tmp_output_dir, 'test.nii.gz'),
False)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.GENERIC_COMPRESSED)[0])
results = dicom2nifti.dicom_series_to_nifti(test_data.GENERIC_COMPRESSED,
os.path.join(tmp_output_dir, 'test.nii.gz'),
True)
assert_compare_nifti(results['NII_FILE'],
ground_thruth_filenames(test_data.GENERIC_COMPRESSED)[1])
finally:
shutil.rmtree(tmp_output_dir)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Tue Nov 5 12:54:03 2019 @author: leonardo """ import dicom2nifti import os import glob dwi_path = '/home/leonardo/Scrivania/TESI/dati/MRI_DWI/Patient55_AIM55/2017-09__Studies/Patient55_AIM55_MR_2017-09-28_081424_rm.encefalo.+.midollo.mdc_DWI.HR_n540__00000' dicom2nifti.dicom_series_to_nifti(dwi_path, '/home/leonardo/Scrivania/a')
path1='G:\ADNI数据\GAN-sMCI\ADNI/'
dirs1=os.listdir(path1)
j=1
k=1
for i_dirs1 in dirs1:
if os.path.exists('G:\AAAAA/sMCI/' + i_dirs1) == False:
os.makedirs('G:\AAAAA/sMCI/' + i_dirs1)
path2=path1+i_dirs1+'\MPRAGE/'
dirs2=os.listdir(path2)
for i_dirs2 in dirs2:
path3=path2+i_dirs2+ '/'
dirs3 = os.listdir(path3)
for i_dirs3 in dirs3:
path4 = path3+i_dirs3
print(path4)
dicom2nifti.dicom_series_to_nifti(path4,'G:\AAAAA/sMCI/'+i_dirs1+'/'+str(k)+'.nii')
k=k+1
if k==4:
k=1
# import torch
# import torch.nn as nn
# from torch.nn import functional as F
# import numpy as np
#
#
# class SAM_Loss(nn.Module):
# def __init__(self):
# super(SAM_Loss, self).__init__()
#
# def SAM_Loss(self, img_base, img_out):
# Write the fMRI data
the_file = open(filename, "w")
j = 1
k = 1
l = 1
# save the Nifti files into HCP folder in /mnt/hcp01/tnfcs_PI folder
for i in (arr):
print ("protocol", i[4])
# B0_fieldmap data
if "B0" in i[4]:
b0_dir = fieldmap_path + "/" + i[1]
field_file = hcp_field + "/" + s_number + "_3T_GradientEchoFieldMap_" + str(j) + ".nii.gz"
dicom2nifti.dicom_series_to_nifti(b0_dir,field_file, reorient_nifti=True)
j = j + 1
# T1w data
if "T1w" in i[4]:
print ("T1w", k)
t1w_dir = t1_path + "/" + i[1]
t1mpr = hcp_un3T_dir + "/T1w_MPR" + str(k)
if not os.path.exists(t1mpr):
os.mkdir(t1mpr)
t1_file = t1mpr + "/" + s_number + "_3T_T1w_MPR" + str(k) + ".nii.gz"
dicom2nifti.dicom_series_to_nifti(t1w_dir,t1_file, reorient_nifti=True)
k = k + 1
# create symbolic link for GradientEchoFieldMap
dst = hcp_field + "/" + s_number + "_3T_GradientEchoFieldMap_" + i[6] + ".nii.gz"
src = t1mpr + "/" + s_number + "_3T_GradientEchoFieldMap.nii.gz"
def generate_ground_truth(dicom_directory, output_file, reoriented_file):
if not os.path.isfile(output_file):
dicom2nifti.dicom_series_to_nifti(dicom_directory, output_file, False)
image_reorientation.reorient_image(output_file, reoriented_file)
import dicom2nifti
main_folder = 'exames-organizados-parte-2'
output_folder = 'nii-parte-2'
folders = sorted(glob.glob('{}/*'.format(main_folder)))
os.makedirs(output_folder, exist_ok=True)
for fold in folders:
print('Processing', fold)
exam_folders = sorted(glob.glob('{}/*/*/*'.format(fold)))
for exam_folder in exam_folders:
print('Exam folder ...', exam_folder)
out_exam_folder = '{}/{}.nii.gz'.format(output_folder, exam_folder)
os.makedirs('/'.join(out_exam_folder.split('/')[0:-1]), exist_ok=True)
try:
dicom2nifti.dicom_series_to_nifti(exam_folder,
out_exam_folder,
reorient_nifti=False)
except Exception as e:
print('Error while converting to', out_exam_folder)
print(e)
print()
def get_nifti(in_dirpath,
out_dirpath,
method='dcm2niix',
compressed=True,
merged=True,
force=False,
verbose=D_VERB_LVL):
"""
Extract images from DICOM files and store them as NIfTI images.
Args:
in_dirpath (str): Input path containing sorted DICOM files.
out_dirpath (str): Output path where to store NIfTI images.
method (str): DICOM to NIfTI conversion method.
Accepted values:
- 'dicom2nifti': use pure Python converter.
- 'isis': use Enrico Reimer's ISIS tool.
https://github.com/isis-group/isis
- 'dcm2nii': Use Chris Rorden's `dcm2nii` tool (old version).
- 'dcm2niix': Use Chris Rorden's `dcm2niix` tool (new version).
compressed (bool): Produce compressed NIfTI using GNU Zip.
The resulting files will have `.nii.gz` extension.
merged (bool): Merge images in the 4th dimension.
Not supported by all methods.
force (bool): Force computation to be re-done.
verbose (int): Set level of verbosity.
Returns:
"""
msg(':: Exporting NIfTI images ({})...'.format(method))
msg('Input: {}'.format(in_dirpath))
msg('Output: {}'.format(out_dirpath))
# proceed only if output is not likely to be there
if not os.path.exists(out_dirpath) or force:
# :: create output directory if not exists and extract images
if not os.path.exists(out_dirpath):
os.makedirs(out_dirpath)
sources = utl.dcm_sources(in_dirpath)
d_ext = '.' + utl.EXT['niz'] if compressed else utl.EXT['nii']
# :: extract nifti
if method == 'dicom2nifti':
for src_id in sorted(sources.keys()):
in_filepath = os.path.join(in_dirpath, src_id)
out_filepath = os.path.join(out_dirpath, src_id + d_ext)
dicom2nifti.dicom_series_to_nifti(in_filepath,
out_filepath,
reorient_nifti=True)
elif method == 'dcm2nii':
for src_id in sorted(sources.keys()):
in_filepath = os.path.join(in_dirpath, src_id)
# produce nifti file
opts = ' -f n ' # influences the filename
opts += ' -t n -p n -i n -d n -e y'
opts += ' -4 ' + 'y' if merged else 'n'
opts += ' -g ' + 'y' if compressed else 'n'
cmd = method + ' {} -o {} {}'.format(opts, out_dirpath,
in_filepath)
ret_val, p_stdout, p_stderr = utl.execute(cmd, verbose=verbose)
term_str = 'GZip...' if compressed else 'Saving '
lines = p_stdout.split('\n') if p_stdout else ()
# parse result
old_names = []
for line in lines:
if term_str in line:
old_name = line[line.find(term_str) + len(term_str):]
old_names.append(old_name)
if old_names:
msg('Parsed names: ', verbose, VERB_LVL['debug'])
msg(''.join([': {}\n'.format(n) for n in old_names]),
verbose, VERB_LVL['debug'])
else:
msg('E: Could not locate filename in `dcm2nii`.')
if len(old_names) == 1:
old_filepath = os.path.join(out_dirpath, old_names[0])
out_filepath = os.path.join(out_dirpath, src_id + d_ext)
msg('NIfTI: {}'.format(out_filepath[len(out_dirpath):]))
os.rename(old_filepath, out_filepath)
else:
for num, old_name in enumerate(old_names):
old_filepath = os.path.join(out_dirpath, old_name)
out_filepath = os.path.join(
out_dirpath,
src_id + utl.INFO_SEP + str(num + 1) + d_ext)
msg('NIfTI: {}'.format(
out_filepath[len(out_dirpath):]))
os.rename(old_filepath, out_filepath)
elif method == 'dcm2niix':
for src_id in sorted(sources.keys()):
in_filepath = os.path.join(in_dirpath, src_id)
# produce nifti file
opts = ' -f __img__ ' # set the filename
opts += ' -9 -t n -p y -i n -d n -b n '
opts += ' -z ' + 'y' if compressed else 'n'
cmd = method + ' {} -o {} {}'.format(opts, out_dirpath,
in_filepath)
utl.execute(cmd, verbose=verbose)
old_names = glob.glob(
os.path.join(out_dirpath,
'__img__*.nii' + '.gz' if compressed else ''))
if len(old_names) == 1:
old_filepath = os.path.join(out_dirpath, old_names[0])
out_filepath = os.path.join(out_dirpath, src_id + d_ext)
msg('NIfTI: {}'.format(out_filepath[len(out_dirpath):]))
os.rename(old_filepath, out_filepath)
else:
for num, old_name in enumerate(old_names):
old_filepath = os.path.join(out_dirpath, old_name)
out_filepath = os.path.join(
out_dirpath,
src_id + utl.INFO_SEP + str(num + 1) + d_ext)
msg('NIfTI: {}'.format(
out_filepath[len(out_dirpath):]))
os.rename(old_filepath, out_filepath)
elif method == 'isis':
for src_id in sorted(sources.keys()):
in_filepath = os.path.join(in_dirpath, src_id)
out_filepath = os.path.join(out_dirpath, src_id + d_ext)
cmd = 'isisconv -in {} -out {}'.format(in_filepath,
out_filepath)
ret_val, p_stdout, p_stderr = utl.execute(cmd, verbose=verbose)
if merged:
# TODO: implement volume merging
msg('W: (isisconv) merging after not implemented.',
verbose, VERB_LVL['medium'])
else:
msg('W: Unknown method `{}`.'.format(method))
else:
msg('I: Skipping existing output path. Use `force` to override.')
def generate_ground_truth(dicom_directory, output_file, reoriented_file):
if not os.path.isfile(output_file):
dicom2nifti.dicom_series_to_nifti(dicom_directory, output_file, False)
image_reorientation.reorient_image(output_file, reoriented_file)
"""
Created on Thu Jul 25 17:08:30 2019
@author: leonardo
"""
import dicom2nifti
import os
os.chdir('/home/leonardo/Scrivania/TESI/dati/pazienti_20190725/Patients_Anonymized+RTstnii')
patients_list=os.listdir()
for patient in patients_list:
os.chdir('/home/leonardo/Scrivania/TESI/dati/pazienti_20190725/Patients_Anonymized+RTstnii/'+patient)
folder_list=os.listdir()
for folder in folder_list:
if 'kVCT' in folder:
CT_path='/home/leonardo/Scrivania/TESI/dati/pazienti_20190725/Patients_Anonymized+RTstnii/'+patient+'/'+folder
continue
output_path='/home/leonardo/Scrivania/TESI/dati/pazienti_20190725/Patients_Anonymized+RTstnii/'+patient+'/CT.nii'
dicom2nifti.dicom_series_to_nifti(CT_path,output_path)
def extract_images(filedata, i, nifti_destination, flattened_to_level, failed, is16Bit):
#ds = dicom.dcmread(filedata.iloc[i].loc['file'], force=True) # read file in
#dicom2nifti.dicom_series_to_nifti(filedata.iloc[i].loc['file'], )
found_err=None
filemapping = ""
fail_path = ""
try:
if flattened_to_level == 'patient':
ID = filedata.iloc[i].loc['PatientID'] # Unique identifier for the Patient.
folderName = hashlib.sha224(ID.encode('utf-8')).hexdigest()
# check for existence of patient folder. Create if it does not exist.
os.makedirs(nifti_destination + folderName,exist_ok=True)
elif flattened_to_level == 'study':
ID1 = filedata.iloc[i].loc['PatientID'] # Unique identifier for the Patient.
try:
ID2 = filedata.iloc[i].loc['StudyInstanceUID'] # Unique identifier for the Study.
except:
ID2='ALL-STUDIES'
folderName = hashlib.sha224(ID1.encode('utf-8')).hexdigest() + "/" + \
hashlib.sha224(ID2.encode('utf-8')).hexdigest()
# check for existence of the folder tree patient/study/series. Create if it does not exist.
os.makedirs(nifti_destination + folderName,exist_ok=True)
imName = hashlib.sha224(filedata.iloc[i].loc['SeriesDescription'].encode('utf-8')).hexdigest()
else:
ID1=filedata.iloc[i].loc['PatientID'] # Unique identifier for the Patient.
try:
ID2=filedata.iloc[i].loc['StudyInstanceUID'] # Unique identifier for the Study.
ID3=filedata.iloc[i].loc['SeriesInstanceUID'] # Unique identifier of the Series.
except:
ID2='ALL-STUDIES'
ID3='ALL-SERIES'
folderName = hashlib.sha224(ID1.encode('utf-8')).hexdigest() + "/" + \
hashlib.sha224(ID2.encode('utf-8')).hexdigest() + "/" + \
hashlib.sha224(ID3.encode('utf-8')).hexdigest()
# check for existence of the folder tree patient/study/series. Create if it does not exist.
os.makedirs(nifti_destination + folderName,exist_ok=True)
niftifile = nifti_destination+folderName + '/' ID1 +'_' +ID2 +'_' +ID3 + '.nii.gz'
dicom2nifti.dicom_series_to_nifti(str(filedata.iloc[i].loc['file']),niftifile)
filemapping = filedata.iloc[i].loc['file'] + ',' + niftifile + '\n'
except AttributeError as error:
found_err = error
logging.error(found_err)
fail_path = filedata.iloc[i].loc['file'], failed + '1/' + \
os.path.split(filedata.iloc[i].loc['file'])[1][:-4]+'.dcm'
except ValueError as error:
found_err = error
logging.error(found_err)
fail_path = filedata.iloc[i].loc['file'], failed + '2/' + \
os.path.split(filedata.iloc[i].loc['file'])[1][:-4]+'.dcm'
except BaseException as error:
found_err = error
logging.error(found_err)
fail_path = filedata.iloc[i].loc['file'], failed + '3/' + \
os.path.split(filedata.iloc[i].loc['file'])[1][:-4]+'.dcm'
except Exception as error:
found_err = error
logging.error(found_err)
fail_path = filedata.iloc[i].loc['file'], failed + '4/' + \
os.path.split(filedata.iloc[i].loc['file'])[1][:-4]+'.dcm'
return (filemapping, fail_path, found_err)
import os
# dicom_dir = "D://media/sample/"
# dicom_dir = "D://media//medical//lsw//benign_65//fpAML_55"
# dicom_dir = "D:\media\medical\lsw//benign_65\oncocytoma_10"
dicom_dir = "/home1/quanquan/datasets/lsw/benign_65/fpAML_55"
# output_dir = "D://media//medical//lsw_trans//benign_65//fpAML_55//"
# output_dir = "D:\media\medical\lsw//benign_65\oncocytoma_10"
output_dir = "/home1/quanquan/datasets/lsw_trans/benign_65/fpAML_55"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
error_names = []
for d in os.listdir(dicom_dir):
print("DIR: ", d)
if os.path.isdir(os.path.join(dicom_dir, d)):
nii_name = os.path.join(output_dir, d + ".nii.gz")
if os.path.exists(os.path.join(nii_name)):
continue
print("Converting... ", d)
try:
dicom2nifti.dicom_series_to_nifti(os.path.join(dicom_dir, d),
nii_name,
reorient_nifti=False)
except Exception as e:
error_names.append(d)
print(e)
print("Error files: ", error_names)
# dicom2nifti.convert_directory()
# pip install dicom2nifti git clone [email protected]:thomshaw92/dicom2nifti.git import dicom2nifti import dicom2nifti.settings as settings from pathlib import Path dicom = Path("path/to/dicom_dir") output = "path/to/nifti.nii.gz" (dicom2nifti.dicom_series_to_nifti(dicom, output, reorient_nifti=True))
stack = np.empty(sliceSize + (len(dcmFilePathList)), dtype=np.uint8)
for dcmFileIndex, dcmFilePath in enumerate(dcmFilePathList):
npImg, rescaleSlope, rescaleIntercept = loadDICOMAsNumpy(dcmFilePath)
sliceImg = processMethod(npImg, rescaleSlope, rescaleIntercept)
sliceImg = cv2.resize(sliceImg,
sliceSize,
interpolation=cv2.INTER_CUBIC)
stack[:, :, dcmFileIndex] = sliceImg
niiStack = nib.Nifti1Image(stack, np.eye(4))
print("Writing output")
niiStack.to_filename(niiOutputPath)
if __name__ == "__main__":
dcmDirPath = "J:\\Chirinos Projects 6 Penn Tower Team\\Liver Scans\\16317654\\CT 5MM AP"
dicom2nifti.dicom_series_to_nifti(dcmDirPath,
"test.nii.gz",
reorient_nifti=True)
#dcmFilePathList = glob.glob(os.path.join(dcmDirPath, "*.dcm"))
#dcmFilePathList = sortDCMFilePaths(dcmFilePathList)
#dcmFirst = pydicom.dcmread(dcmFilePathList[0], specific_tags=["ImagePositionPatient", "ImageOrientationPatient", "PixelSpacing"])
#dcmLast = pydicom.dcmread(dcmFilePathList[-1], specific_tags=["ImagePositionPatient", "ImageOrientationPatient", "PixelSpacing"])
#affine = dicom2nifti.common.create_affine([dcmFirst, dcmLast])
#dcmToNIIRaw(dcmDirPath, niiOutputPath="output.nii.gz")
label1CSV = diseaselist['Label1']
# Retrieve Disease Label
report_index = reportCSV.index(
str(patient_report_list[patient_reports]))
diseaselabel0 = label0CSV[report_index]
diseaselabel1 = label1CSV[report_index]
# Multiple Diseases
if (len(diseaselabel1) > 3):
print('Labels: {}; {}'.format(diseaselabel0,
diseaselabel1))
output_file = raw_save_path + 'MultipleDiseases/' + name
if not os.path.exists(output_file): # Disable Overwriting
dicom2nifti.dicom_series_to_nifti(scans_path,
output_file,
reorient_nifti=True)
# Single Disease
else:
print('Label: {}'.format(diseaselabel0))
output_file = raw_save_path + diseaselabel0.strip(
) + '/' + name
if not os.path.exists(output_file): # Disable Overwriting
dicom2nifti.dicom_series_to_nifti(scans_path,
output_file,
reorient_nifti=True)
patient_DICOM_name_list.append(raw_list[patient])
patient_report_number_list.append(
patient_report_list[patient_reports])
def deepmedic_process(input_json_string):
t = time.time()
request_id, output_path, dicoms_paths, niftis_path, flirt_path, bet2_path, config_files_path, saved_model_path, processor, temp_path = init(input_json_string)
# dicom2nifti
send_status(request_id, 'dicom2nifti conversion started', 102)
for i in list(dicoms_paths.keys()):
dicom2nifti.dicom_series_to_nifti(dicoms_paths[i], os.path.join(niftis_path, i))
send_status(request_id, '%s converted to nifti'%i, 102)
# register flair based on t1c
send_status(request_id, 'registration started', 102)
try:
subprocess.run('{0}{1} -in {2} -ref {3} -out {2}_registered -interp nearestneighbour'.format(executer, flirt_path, os.path.join(niftis_path, 'flair'), os.path.join(niftis_path, 't1c')), shell=True, check=True)
send_status(request_id, 'flair registered based on t1c', 102)
except subprocess.CalledProcessError as error:
send_status(request_id, 'registration failed. error: %s'%error, 500)
# brain_extraction
send_status(request_id, 'brain extraction started', 102)
try:
subprocess.run('{0}{1} {2}.nii {2}_brain.nii -m'.format(executer, bet2_path, os.path.join(niftis_path, 'flair_registered')), shell=True, check=True)
send_status(request_id, 'flair brain extracted', 102)
subprocess.run('{0}{1} {2} {2}_brain -m'.format(executer, bet2_path, os.path.join(niftis_path, 't1c')), shell=True, check=True)
send_status(request_id, 't1c brain extracted', 102)
except subprocess.CalledProcessError as error:
send_status(request_id, 'brain extraction failed. error: %s'%error, 500)
# image_normalization
send_status(request_id, 'image normalization started', 102)
image_normalization(os.path.join(niftis_path, 'flair_registered_brain'))
send_status(request_id, 'flair normalized', 102)
image_normalization(os.path.join(niftis_path, 't1c_brain'))
send_status(request_id, 't1c normalized', 102)
#config and run
send_status(request_id, 'deepmedic running started', 102)
test_flair_file_name = 'flair_registered_brain_normalized.nii'
test_t1c_file_name = 't1c_brain_normalized.nii'
mask = 't1c_brain_mask.nii'
prediction_file_name = 'predic_flair.nii.gz'
deepmedic_config(config_files_path, niftis_path, test_flair_file_name, test_t1c_file_name, mask, prediction_file_name, output_path)
model_cfg_file_path = os.path.join(config_files_path, 'model', 'modelConfig.cfg')
test_cfg_file_path = os.path.join(config_files_path, 'test', 'testConfig.cfg')
result = deepmedic_runner(device_name=processor,
model_cfg_file_path=model_cfg_file_path,
test_cfg_file_path=test_cfg_file_path,
train_cfg_file_path=None,
saved_model_path=saved_model_path,
reset_trainer=False)
send_status(request_id, 'the project successfully ran in %s seconds' % int(time.time()-t), 200)
output_seg_path = os.path.join(output_path, 'predictions', 'testSessionDm', 'predictions', 'predic_flair_Segm.nii.gz')
output_json_dict = {
"request_id" : request_id,
"result" : result,
"generated_files" : {"tag" : "flair", "path" : output_seg_path},
}
with open(os.path.join(temp_path, 'deepmedicModule_result.txt'), 'w') as result_file:
result_file.write(str(output_json_dict))
return json.dumps(output_json_dict)
def convert_data():
if verbose:
print('Converting to nifti')
dicom2nifti.dicom_series_to_nifti(f'{tmpdir}/dicom', f'{tmpdir}/t1.nii.gz', reorient_nifti=True)
if not os.path.exists(output):
os.mkdir(output)
files, patients, folders = os.walk(inp).next()
for p in patients:
print p
path = files + '/' + p
depth_1 = os.listdir(path)
for seq in depth_1:
# print seq
path_2 = path + '/' + seq
depth_2 = os.listdir(path_2)
for seq2 in depth_2:
# print seq2
hnc_input_path = path_2 + '/' + seq2
# print hnc_input_path
hnc_output_path = output + '/' + p
if not os.path.exists(hnc_output_path):
os.mkdir(hnc_output_path)
try:
dicom2nifti.dicom_series_to_nifti(hnc_input_path,
hnc_output_path + '/' + p +
'.nii.gz',
reorient_nifti=True)
except:
print
# dicom2nifti.dicom_series_to_nifti(original_dicom_directory, output_file, reorient_nifti=True)
# os.system('dicom2nifti '+hnc_input_path+' '+hnc_output_path)
print '***'
or main_folder == 'ADNI 10' or main_folder == 'ADNI 5'
or main_folder == 'ADNI 6' or main_folder == 'ADNI 7') == False):
os.chdir('/Volumes/Drive/Dataset-CMB/ADNI-CMBs/Output')
os.mkdir(main_folder)
output_temp = os.path.join(output, main_folder)
main_target = os.path.join(DIR, main_folder)
os.chdir(main_target)
#print([name for name in os.listdir('.') if os.path.isdir(name)])
for folder in os.listdir('.'):
#filename = folder + '.nii'
target = os.path.join(main_target, folder)
os.chdir(target)
for subfolder in os.listdir('.'):
if (subfolder.endswith(".nii") == False):
newtarget = os.path.join(target, subfolder)
os.chdir(newtarget)
for nextsubfolder in os.listdir('.'):
filename_1 = folder[-4:]
filename = nextsubfolder
filename = filename[:-11]
filename = re.sub('[-]', '', filename)
filename = filename_1 + '_' + filename + '.nii'
output = os.path.join(output_temp, filename)
final_target = os.path.join(newtarget, nextsubfolder)
d2n.dicom_series_to_nifti(final_target,
output,
reorient_nifti=True)
async def dcmhandler(channel, ds, uri, routing_key):
print(f"dcm2niix: converting {uri} ({ds.SeriesDescription})")
outdir = f"{os.environ['HOME']}/.dcmq/nii/{ds.StudyInstanceUID}"
pathlib.Path(outdir).mkdir(parents=True, exist_ok=True)
count = 0
with os.scandir(uri) as it:
for series in it:
if series.is_dir():
with os.scandir(series) as it2:
for instance in it2:
if instance.is_file():
dcmfilename = instance.name
break
refds = dcmread(os.path.join(uri, series.name, dcmfilename))
try:
if not Tag(
"ImageType"
) in refds or not "PRIMARY" in refds.ImageType or "RESAMPLED" in ds.ImageType: #only convert primary data
print(
f"dcm2niix: {os.path.join(uri, series.name)} ({refds.SeriesDescription}) is not a primary image"
)
continue
except Exception as e:
print(e)
outfile = os.path.join(outdir,
refds.SeriesInstanceUID + ".nii")
try:
indir = os.path.join(uri, series.name)
cmd = f"dcm2niix -f %j -o {outdir} -b n -m y {indir}"
print(cmd)
ret = os.system(cmd)
if ret == 0:
if os.path.exists(
os.path.join(
outdir,
refds.SeriesInstanceUID + "_Tilt_1.nii")):
outfile = os.path.join(
outdir,
refds.SeriesInstanceUID + "_Tilt_1.nii")
if os.path.exists(
os.path.join(
outdir, refds.SeriesInstanceUID +
"_Tilt_Eq_1.nii")):
outfile = os.path.join(
outdir,
refds.SeriesInstanceUID + "_Tilt_Eq_1.nii")
if os.path.exists(outfile):
await publish(channel,
"stored.series.nii",
refds,
uri=outfile)
count += 1
else:
print(
f"dcm2niix: error converting {series.name} ({refds.SeriesDescription}): outfile not found"
)
else:
print(
f"dcm2niix: error converting {series.name} ({refds.SeriesDescription}): exited with error code {ret}"
)
print(f"dcm2niix: retrying with dicom2nifti")
dicom2nifti.dicom_series_to_nifti(indir,
outfile,
reorient_nifti=True)
count += 1
await publish(channel,
"stored.series.nii",
refds,
uri=outfile)
except Exception as e:
print(
f"dcm2niix: error converting {series.name} ({refds.SeriesDescription}): {e}"
)
continue
if count > 0:
await publish(channel, "stored.study.nii", ds, uri=outdir)
def test_main_function(self):
tmp_output_dir = tempfile.mkdtemp()
try:
results = dicom2nifti.dicom_series_to_nifti(
test_data.SIEMENS_ANATOMICAL,
os.path.join(tmp_output_dir, 'test.nii.gz'), False)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.SIEMENS_ANATOMICAL)[0]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.SIEMENS_ANATOMICAL,
os.path.join(tmp_output_dir, 'test.nii.gz'), True)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.SIEMENS_ANATOMICAL)[1]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.SIEMENS_ANATOMICAL_IMPLICIT,
os.path.join(tmp_output_dir, 'test.nii.gz'), False)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.SIEMENS_ANATOMICAL_IMPLICIT)[0]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.SIEMENS_ANATOMICAL_IMPLICIT,
os.path.join(tmp_output_dir, 'test.nii.gz'), True)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.SIEMENS_ANATOMICAL_IMPLICIT)[1]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.GENERIC_ANATOMICAL,
os.path.join(tmp_output_dir, 'test.nii.gz'), False)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.GENERIC_ANATOMICAL)[0]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.GENERIC_ANATOMICAL,
os.path.join(tmp_output_dir, 'test.nii.gz'), True)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.GENERIC_ANATOMICAL)[1]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.GENERIC_ANATOMICAL_IMPLICIT,
os.path.join(tmp_output_dir, 'test.nii.gz'), False)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.GENERIC_ANATOMICAL_IMPLICIT)[0]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.GENERIC_ANATOMICAL_IMPLICIT,
os.path.join(tmp_output_dir, 'test.nii.gz'), True)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.GENERIC_ANATOMICAL_IMPLICIT)[1]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.GENERIC_COMPRESSED,
os.path.join(tmp_output_dir, 'test.nii.gz'), False)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.GENERIC_COMPRESSED)[0]) == True
results = dicom2nifti.dicom_series_to_nifti(
test_data.GENERIC_COMPRESSED,
os.path.join(tmp_output_dir, 'test.nii.gz'), True)
assert compare_nifti(
results['NII_FILE'],
ground_thruth_filenames(
test_data.GENERIC_COMPRESSED)[1]) == True
finally:
shutil.rmtree(tmp_output_dir)
src = "/Users/monicasilva/Documents/2_Preprocessing/2.1_Preprocessing_T2ax/T2ax_dicom"
dst = "/Users/monicasilva/Documents/2_Preprocessing/2.1_Preprocessing_T2ax/T2ax_nifty/T2ax_nii_files"
listOfDirectories = []
listOfFiles = []
listOfIDs4Files = []
pString = "P"
for root, directories, fileNames in os.walk(src):
if root == "/Users/monicasilva/Documents/2_Preprocessing/2.1_Preprocessing_T2ax/T2ax_dicom/P001":
break
listOfDirectories = directories
listOfDirectories.sort()
for directory in listOfDirectories:
patientDir = directory
a = os.walk(os.path.join(src, directory))
for rootPatient, directoriesPatient, filenamesPatient in os.walk(
os.path.join(src, directory)):
directoriesPatient.sort()
aux = 0
for directorySequence in directoriesPatient: # for each sequence folder
string = str(directorySequence) + ".nii"
dicom2nifti.dicom_series_to_nifti(os.path.join(
src, directory, directorySequence),
os.path.join(dst, string),
reorient_nifti=True)
aux += 1
if aux == 2:
break
