def multidicom2multidicom(in_dirs, dicomdir, plans, out_prefix):
import dicom
import DicomIO
import numpy as np
import os
import shutil
outdir = experiment_dir + '/' + out_prefix + '/' + dicomdir
if not os.path.exists(outdir):
os.makedirs(outdir)
else:
shutil.rmtree(outdir)
os.makedirs(outdir)
# Resolve new frame list
out_vols = plans
dcmio = DicomIO.DicomIO()
for dir_i in range(len(in_dirs)):
print "Reading " + in_dirs[dir_i]
frame_list = dcmio.ReadDICOM_frames(in_dirs[dir_i])
no_slices = len(frame_list[0])
for z_i in range(no_slices):
out_vols[dir_i][z_i].PixelData = frame_list[0][
z_i].pixel_array.astype(np.uint16).tostring()
dcmio = DicomIO.DicomIO()
filenames = dcmio.WriteDICOM_frames(outdir, out_vols, 'IM')
return outdir, filenames
def DICOM2animatedGIF_sidebyside(dcmdir_l, dcmdir_r, outputpath, slice_i, suffix):
dcmio = DicomIO.DicomIO()
dwidcm_l = dcmio.ReadDICOM_frames(dcmdir_l)
dwidcm_r = dcmio.ReadDICOM_frames(dcmdir_r)
# Write all frames of slice into set of png files
for frame_i in range(len(dwidcm_l)):
slice_l = dwidcm_l[frame_i][slice_i].pixel_array.T
slice_r = dwidcm_r[frame_i][slice_i].pixel_array.T
dimx = slice_l.shape[0]
dimy = slice_l.shape[1]
newImg1 = PIL.Image.new('L', (dimx*2, dimy))
pixels1 = newImg1.load()
for i in range (0, dimx):
for j in range (0, dimy):
pixels1[i, j] = float(slice_l[i, j])
pixels1[dimx+i, j] = float(slice_r[i, j])
#pixels1[i, j] = float(slice[i, j]) * dwidcm[frame_i][slice_i].RescaleSlope + dwidcm[frame_i][slice_i].RescaleIntercept
newImg1.save((outputpath + '_' + ('%02d' % frame_i) + '.png'),'PNG')
cmd = CommandLine('convert -delay 25 -loop 0 %s_*.png %s_%s.gif' % (outputpath, outputpath, suffix))
cmd.run()
for frame_i in range(len(dwidcm_l)):
os.remove((outputpath + '_' + ('%02d' % frame_i) + '.png'))
print "convert (ImageMagick):" + cmd.cmd
return (outputpath + '.gif')
def singletiff2multidicom(in_files, dicomdir, plans, out_prefix):
import DicomIO
import numpy as np
import os
import shutil
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore")
import tifffile as tiff
outdir = experiment_dir + '/' + out_prefix + '/' + dicomdir
if not os.path.exists(outdir):
os.makedirs(outdir)
else:
shutil.rmtree(outdir)
os.makedirs(outdir)
# Resolve new frame list
out_vols = plans
for file_i in range(len(in_files)):
print "Reading " + in_files[file_i]
ds = tiff.imread(in_files[file_i])
no_slices = ds.shape[0]
for z_i in range(no_slices):
out_vols[file_i][z_i].PixelData = ds[z_i].astype(
np.uint16).tostring()
dcmio = DicomIO.DicomIO()
filenames = dcmio.WriteDICOM_frames(outdir, out_vols, 'IM')
return outdir, filenames
def multidicom2multidicom(in_dirs, dicomdir, experiment_dir, out_prefix):
import dicom
import DicomIO
import numpy as np
import os
import shutil
outdir = experiment_dir + '/' + out_prefix + '/' + dicomdir
if not os.path.exists(outdir):
os.makedirs(outdir)
else:
shutil.rmtree(outdir)
os.makedirs(outdir)
# Resolve new frame list
out_vols = []
dcmio = DicomIO.DicomIO()
for dir_i in range(len(in_dirs)):
print "Reading directory:" + in_dirs[dir_i]
frame_list = dcmio.ReadDICOM_frames(in_dirs[dir_i])
no_slices = len(frame_list[0])
for z_i in range(no_slices):
frame_list[0][z_i].NumberOfTimeSlices = len(in_dirs)
out_vols.append(frame_list[0])
filenames = dcmio.WriteDICOM_frames(outdir, out_vols, 'IM')
return outdir, filenames
def get_subvolumes(input_dir, volume_list, bounds, output_prefix):
import dicom
import DicomIO
import shutil
import numpy as np
dcmio = DicomIO.DicomIO()
from nipype.utils.filemanip import split_filename
# resolve output directory and volumes
out_dir_base = experiment_dir + '/' + output_prefix + '/' + 'subvolumes'
filenames_all = []
outdirs_all = []
out_vols_all = []
for vol_i in range(len(volume_list)):
out_dir = out_dir_base + '_' + str(volume_list[vol_i])
out_vols = []
dwivolume = dwidcm[volume_list[vol_i]]
#take subregion from volume
for slice_i in range(len(dwivolume)):
pixel_array = dwivolume[slice_i].pixel_array[bounds[2]:bounds[3],bounds[0]:bounds[1]]
dwivolume[slice_i].PixelData = pixel_array.astype(np.uint16).tostring()
dwivolume[slice_i].Columns = bounds[1]-bounds[0]
dwivolume[slice_i].Rows = bounds[3]-bounds[2]
#append volume to lists
out_vols.append(dwivolume)
out_vols_all.append(dwivolume)
# Create output directory if it does not exist
if not os.path.exists(out_dir):
os.makedirs(out_dir)
else:
shutil.rmtree(out_dir)
os.makedirs(out_dir)
filenames = dcmio.WriteDICOM_frames(out_dir, out_vols, 'IM')
filenames_all.append(filenames)
outdirs_all.append(out_dir)
return outdirs_all, filenames_all, out_vols_all
def DICOM2ASCII(in_dir, out_dir, out_prefix, subwindow):
import dicom
import DicomIO
import bfitASCII_IO
import numpy as np
import os
import shutil
outdir = out_dir + '/' + out_prefix + '_' + in_dir + '_ASCII.txt'
if os.path.isfile(outdir):
os.remove(outdir)
# Resolve new frame list
dcmio = DicomIO.DicomIO()
frame_list = dcmio.ReadDICOM_frames(experiment_dir + '/' + out_prefix +
'/' + in_dir)
slice_1st = frame_list[0][0]
xdim = slice_1st.Columns
ydim = slice_1st.Rows
zdim = slice_1st.NumberOfSlices
tdim = slice_1st.NumberOfTimeSlices
ROI_No = 0
bset = []
for frame_i in range(len(frame_list)):
bset.append(int(frame_list[frame_i][0].FrameReferenceTime) / 1000)
ROIslice = []
for slice_i in range(len(frame_list[0])):
ROIslice.append(slice_i + 1)
name = in_dir
# Save in data in order z,y,x
SIs = []
for z_i in range(zdim):
for y_i in range(offset, ydim - offset):
for x_i in range(offset, xdim - offset):
SI = []
for t_i in range(tdim):
SI.append(frame_list[t_i][z_i].pixel_array[y_i, x_i] *
frame_list[t_i][z_i].RescaleSlope +
frame_list[t_i][z_i].RescaleIntercept)
SIs.append(SI)
print str(z_i + 1) + '/' + str(zdim)
print "total SIs:" + str(len(SIs))
data = {
'subwindow': subwindow,
'ROI_No': ROI_No,
'bset': bset,
'ROIslice': ROIslice,
'name': name,
'SIs': SIs
}
ASCIIio = bfitASCII_IO.bfitASCII_IO()
print("Writing " + outdir)
ASCIIio.Write3D(outdir, data)
return outdir
def print_dcm(input_file):
import DicomIO
dcmio = DicomIO.DicomIO()
dwidcm = dcmio.ReadDICOM_frames(input_file)
for vol_i in range(len(dwidcm)):
print "frame " + str(vol_i+1)
for z_i in range(len(dwidcm[vol_i])):
print str(dwidcm[vol_i][z_i].FrameReferenceTime) + " - " + str(dwidcm[vol_i][z_i].ImagePositionPatient[2])
def singletiff2multidicom(in_files, dicomdir, plans, experiment_dir,
out_prefix):
import DicomIO
import numpy as np
import os
import shutil
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore")
import tifffile as tiff
outdir = experiment_dir + os.sep + out_prefix + os.sep + dicomdir
if not os.path.exists(outdir):
os.makedirs(outdir)
else:
shutil.rmtree(outdir)
os.makedirs(outdir)
# Resolve new frame list
out_vols = plans
for file_i in range(len(in_files)):
print "Reading " + in_files[file_i]
ds = tiff.imread(in_files[file_i])
no_slices = ds.shape[0]
for z_i in range(no_slices):
ds_slice = ds[z_i]
#ds_slice = ds[z_i]*out_vols[file_i][z_i].RescaleSlope+out_vols[file_i][z_i].RescaleIntercept
print "Mean before: " + str(
np.mean(out_vols[file_i][z_i].pixel_array) *
out_vols[file_i][z_i].RescaleSlope +
out_vols[file_i][z_i].RescaleIntercept) + " " + str(
np.mean(ds_slice))
ds_slice_min = np.amin(ds_slice)
ds_intercept = ds_slice_min
ds_slice = ds_slice - ds_intercept
ds_range = np.amax(ds_slice)
ds_slope = ds_range / 65535.0
if ds_slope > 0:
ds_slice = ds_slice / ds_slope
ds_slice = ds_slice.astype(np.uint16)
print "Mean after: " + str(
np.mean(ds_slice) * ds_slope + ds_intercept)
out_vols[file_i][z_i].PixelData = np.round(ds_slice).astype(
np.uint16).tostring()
out_vols[file_i][z_i].RescaleSlope = ds_slope
out_vols[file_i][z_i].RescaleIntercept = ds_intercept
dcmio = DicomIO.DicomIO()
filenames = dcmio.WriteDICOM_frames(outdir, out_vols, 'IM')
return outdir, filenames
def resolve_DICOMROI_imgdata(DICOMpath, xy_bounds=None, z_slices=None):
import scipy.io
import numpy as np
import DicomIO
dcmio = DicomIO.DicomIO()
DICOM_ROIdata = dcmio.ReadDICOM_frames(DICOMpath)
# Create and write mask images
print str(len(DICOM_ROIdata)) + " ROIs"
# Create mask around combined ROIs
ROIpixel_array_all = []
ROInames = []
# Go through all ROIs
dim = [
DICOM_ROIdata[0][0].pixel_array.shape[0],
DICOM_ROIdata[0][0].pixel_array.shape[1],
len(DICOM_ROIdata[0])
]
for roi_i in range(len(DICOM_ROIdata)):
if not xy_bounds == None:
ROI = np.zeros(shape=(xy_bounds[1] - xy_bounds[0],
xy_bounds[3] - xy_bounds[2], dim[2]))
for z in range(dim[2]):
ROI[:, :, z] = DICOM_ROIdata[roi_i][z].pixel_array[
xy_bounds[0]:xy_bounds[1], xy_bounds[2]:xy_bounds[3]]
else:
ROI = np.zeros(shape=(dim[0], dim[1], dim[2]))
for z in range(dim[2]):
ROI[:, :, z] = DICOM_ROIdata[roi_i][z].pixel_array
ROInames.append('ROI' + ('%02d' % roi_i))
ROIpixel_array_all.append(ROI)
return ROIpixel_array_all, ROInames
help="Subregion filename in working directory",
required=True)
args = parser.parse_args()
subdirs = os.listdir(experiment_dir + os.sep + args.subject)
subdirs_for_QC = []
for subdir_i in range(len(subdirs)):
if os.path.isdir(experiment_dir + os.sep + args.subject + os.sep +
subdirs[subdir_i]) and (
subdirs[subdir_i].find('Motioncorrected_') != -1):
subdirs_for_QC.append(subdirs[subdir_i])
B0_images = []
parameter_files = []
disp_fields = []
print "Loading deformed DICOM image"
dcmio = DicomIO.DicomIO()
dwidcm = dcmio.ReadDICOM_frames(experiment_dir + os.sep + args.subject +
os.sep + 'Motioncorrected')
dwishape = [
dwidcm[0][0].pixel_array.shape[0], dwidcm[0][0].pixel_array.shape[1],
len(dwidcm[0]),
len(dwidcm)
]
for subdir_i in range(len(subdirs_for_QC)):
subdir = experiment_dir + os.sep + args.subject + os.sep + subdirs_for_QC[
subdir_i]
print str(subdir_i) + ':' + subdir
loginfo = read_log(subdir + os.sep + 'elastix.log')
plot_utils.plot_iterationinfo(loginfo, subdir)
def get_boundsmask(output_prefix, input_shape, input_plans, matfilename,
ROIindexes, padding):
import scipy.io
import os
import numpy as np
import copy
mat = scipy.io.loadmat(matfilename)
# Get list of ROIs
ROIs = mat['ROIs'].tolist()[0]
# Get list of slices where ROIs are located
ROIslices = mat['ROIslices'][0].tolist()
# Create and write mask images
print str(len(ROIs)) + " ROIs"
shape = [input_shape[0], input_shape[1]]
# Create mask around combined ROIs
ROIpixel_array_combined = np.zeros(shape)
for roi_i in range(len(ROIindexes)):
ROIlist = ROIs[ROIindexes[roi_i]].tolist()
ROIname = str(ROIlist[0][0][0][0])
ROIpixel_array = ROIlist[0][0][1]
print "catenating " + ROIname
ROIpixel_array_combined = ROIpixel_array_combined + ROIpixel_array
for xi in range(shape[0]):
for yi in range(shape[1]):
if ROIpixel_array_combined[xi][yi] != 0:
ROIpixel_array_combined[xi][yi] = 1
ROIpixel_array, bounds = resolve_boundingbox(ROIpixel_array_combined,
padding)
# Add z bounds to make [xmin,xmax,ymin,ymax,zmin,zmax]
bounds.append(0)
bounds.append(input_shape[2] - 1)
ROI_filenames = []
dcmio = DicomIO.DicomIO()
# Resolve ROI data
ROIlist = ROIs[roi_i].tolist()
ROIname = "Boundingbox"
print ROIname
#print ROIpixel_array
# Resolve output name
out_dir = experiment_dir + '/' + output_prefix + '/' + 'ROImask' + str(
roi_i + 1) + '_' + ROIname
# Place mask into intensity values
output_frame = []
#print str(len(input_frame[0])) + " slices of size " + str(shape)
for slice_i in range(input_shape[2]):
slice = copy.deepcopy(input_plans[slice_i])
if slice_i != ROIslices[0]:
#print "zero-slice:" + str(slice_i) + " " + str(shape)
slice.PixelData = np.zeros(shape).astype(np.uint16).tostring()
else:
#print " ROI-slice:" + str(slice_i) + " " + str(ROIpixel_array.shape)
slice.PixelData = ROIpixel_array.astype(np.uint16).tostring()
output_frame.append(slice)
# Create output directory if it does not exist
if not os.path.exists(out_dir):
os.makedirs(out_dir)
# Write data
filenames = dcmio.WriteDICOM_frames(out_dir, [output_frame], 'IM')
ROI_filenames.append(filenames[ROIslices[0]])
return out_dir, ROI_filenames, ROIslices[0], bounds
def get_subvolumes(input_plans, input_shape, volume_list, bounds,
output_prefix):
import dicom
import DicomIO
import shutil
import numpy as np
from nipype.utils.filemanip import split_filename
dcmio = DicomIO.DicomIO()
print "Original frame dimensions are:" + str(input_shape)
# Resolve output directory and volumes
out_dir_base = experiment_dir + os.sep + output_prefix + os.sep + 'subvolumes'
filenames_all = []
outdirs_all = []
out_vols_all = []
for vol_i in range(len(volume_list)):
out_dir = out_dir_base + '_' + str(volume_list[vol_i])
out_vols = []
dwivolume = dwidcm[volume_list[vol_i]]
# Take subregion from volume
for slice_i in range(input_shape[2]):
pixel_array = dwivolume[slice_i].pixel_array
pixel_array = pixel_array[bounds[0]:bounds[1] + 1,
bounds[2]:bounds[3] + 1]
dwivolume[slice_i].PixelData = pixel_array.astype(
np.uint16).tostring()
dwivolume[slice_i].Columns = pixel_array.shape[1]
dwivolume[slice_i].Rows = pixel_array.shape[0]
dwivolume[slice_i].NumberOfSlices = input_shape[2]
# Append volume to lists
out_vols.append(dwivolume)
out_vols_all.append(dwivolume)
# Create output directory if it does not exist
if not os.path.exists(out_dir):
os.makedirs(out_dir)
print "Writing to dir:" + out_dir
else:
shutil.rmtree(out_dir)
os.makedirs(out_dir)
print "Overwriting to dir:" + out_dir
filenames = dcmio.WriteDICOM_frames(out_dir, out_vols, 'IM')
filenames_all.append(filenames)
outdirs_all.append(out_dir)
# Resolve mask output name
mask_out_dir = experiment_dir + os.sep + output_prefix + os.sep + 'bounds_mask'
# Mask subregion from volume
dwivolume = dwidcm[0]
pixel_array = np.zeros([input_shape[0], input_shape[1]])
pixel_array[bounds[0]:bounds[1] + 1, bounds[2]:bounds[3] + 1] = 1
for slice_i in range(input_shape[2]):
dwivolume[slice_i].PixelData = pixel_array.astype(np.uint16).tostring()
dwivolume[slice_i].Columns = input_shape[0]
dwivolume[slice_i].Rows = input_shape[1]
dwivolume[slice_i].NumberOfSlices = input_shape[2]
dwivolume[slice_i].NumberOfTimeSlices = 1
# Create output directory if it does not exist
if not os.path.exists(mask_out_dir):
os.makedirs(mask_out_dir)
print "Writing to dir:" + mask_out_dir
else:
shutil.rmtree(mask_out_dir)
os.makedirs(mask_out_dir)
print "Overwriting to dir:" + mask_out_dir
mask_filenames = dcmio.WriteDICOM_frames(mask_out_dir, [dwivolume], 'IM')
return outdirs_all, filenames_all, out_vols_all, mask_filenames, mask_out_dir
def ASCII2DICOM(data,
in_dir,
outdir_basename,
in_prefix,
out_prefix,
bounds,
ROIimgs=None,
ROInames=None):
import dicom
import DicomIO
import numpy as np
import os
import shutil
# Resolve new frame list
dcmio = DicomIO.DicomIO()
frame_list = dcmio.ReadDICOM_frames(original_DICOM + os.sep + in_prefix +
os.sep + in_dir)
slice_1st = frame_list[0][0]
xdim = slice_1st.Columns
ydim = slice_1st.Rows
zdim = slice_1st.NumberOfSlices
tdim = slice_1st.NumberOfTimeSlices
sample_frame = frame_list[0]
del frame_list
# Read data = { 'subwindow': subwindow, 'ROI_No': ROI_No, 'bset': bset, 'ROIslice': ROIslice, 'name': name, 'SIs': SIs }
if ROIimgs == None:
img, dim, pmap_names, pmap_slices, pmap_subwindow, bset, name = resolve_ASCIIparamdata(
data)
else:
img, dim, pmap_names, pmap_slices, pmap_subwindow, bset, name = resolve_ASCIIparamdata(
data, ROIimgs[0])
pmap_subwindow = [0, img.shape[0], 0, img.shape[1]]
pmap_slices = range(0, img.shape[2])
print "Pmap image shape:" + str(img.shape)
print "subwindow:" + str(pmap_subwindow)
if not os.path.exists(outdir_basename):
os.makedirs(outdir_basename)
if not os.path.exists(outdir_basename + os.sep + out_prefix):
os.makedirs(outdir_basename + os.sep + out_prefix)
# Save in data in order z,y,x
out_dirs = []
for p_i in range(len(pmap_names)):
out_vols = []
outvolume = sample_frame
print "Writing " + pmap_names[p_i]
for slice_i in range(len(pmap_slices)):
z_i = pmap_slices[slice_i] - 1
# Initialize slice intensity values
pixel_array = np.array([[0] * ydim] * xdim, dtype=np.float64)
# print pixel_array.shape
# print str(len(pmap_SIs[p_i]))
# print str(len(pmap_SIs))
# Place data into slice subregion
for y_i in range(pmap_subwindow[2], pmap_subwindow[3]):
for x_i in range(pmap_subwindow[0], pmap_subwindow[1]):
pixel_array[y_i, x_i] = float(img[y_i - pmap_subwindow[2],
x_i - pmap_subwindow[0],
slice_i, p_i])
# Place data into slice
max_val = np.power(2, 16) - 1
max_pixel_array = np.max(pixel_array)
min_pixel_array = np.min(pixel_array)
r_intercept = min_pixel_array
r_slope = (max_pixel_array - min_pixel_array) / max_val
if r_slope != 0:
pixel_array = np.divide(np.subtract(pixel_array, r_intercept),
r_slope)
else:
pixel_array = np.subtract(pixel_array, r_intercept)
print(min_pixel_array, max_pixel_array, np.min(pixel_array),
np.max(pixel_array), r_intercept, r_slope)
outvolume[z_i].PixelData = pixel_array.astype(np.uint16).tostring()
outvolume[z_i].Columns = xdim
outvolume[z_i].Rows = ydim
outvolume[z_i].NumberOfSlices = zdim
outvolume[z_i].NumberOfTimeSlices = 1
outvolume[z_i].RescaleSlope = r_slope
outvolume[z_i].RescaleIntercept = r_intercept
# Append volume to lists
out_vols.append(outvolume)
# Create output directory if it does not exist
out_dir = outdir_basename + os.sep + out_prefix + os.sep + pmap_names[
p_i]
if not os.path.exists(out_dir):
os.makedirs(out_dir)
else:
shutil.rmtree(out_dir)
os.makedirs(out_dir)
# Write output DICOM
filenames = dcmio.WriteDICOM_frames(out_dir, out_vols, 'IM')
out_dirs.append(out_dir)
return out_dirs, filenames
def ASCII2DICOM(in_refdir, in_file, out_prefix, out_basedir, bounds):
import dicom
import DicomIO
import bfitASCII_IO
import numpy as np
import os
import shutil
import copy
outdir_basename = out_basedir + out_prefix
# Resolve new frame list
dcmio = DicomIO.DicomIO()
frame_list = dcmio.ReadDICOM_frames(in_refdir + '/' + out_prefix + '/' + 'DICOMconverted')
slice_1st = frame_list[0][0]
xdim = slice_1st.Columns
ydim = slice_1st.Rows
zdim = slice_1st.NumberOfSlices
tdim = slice_1st.NumberOfTimeSlices
print "Original data dimensions:" + str([xdim, ydim, zdim, tdim])
sample_frame = frame_list[0]
del frame_list
# Read data = { 'subwindow': subwindow, 'ROI_No': ROI_No, 'bset': bset, 'ROIslice': ROIslice, 'name': name, 'SIs': SIs }
ASCIIio = bfitASCII_IO.bfitASCII_IO()
print ("Reading " + in_file)
data = ASCIIio.Read(in_file, False)
pmap_subwindow = data['subwindow']
pmap_SIs = data['data']
pmap_names = data['parameters']
pmap_names = [s.strip('[],\'') for s in pmap_names]
pmap_slices = data['ROIslice']
pmap_slices = [s-1 for s in pmap_slices]
# Save in data in order z,y,x
out_dirs = []
for p_i in range(len(pmap_names)):
SI_i = 0
outvolume = copy.deepcopy(sample_frame)
out_dir = outdir_basename + '_' + pmap_names[p_i]
print "Writing " + pmap_names[p_i] + ' to ' + out_dir
for z_i in range(zdim):
# Initialize slice intensity values
pixel_array = np.zeros([xdim, ydim])
# Place data into slice subregion
for x_i in range(pmap_subwindow[0], pmap_subwindow[1]+1):
for y_i in range(pmap_subwindow[2], pmap_subwindow[3]+1):
pixel_array[y_i, x_i] = pmap_SIs[SI_i,p_i]
SI_i = SI_i + 1
pixel_array = pixel_array.T
intercept = np.amin(pixel_array)
pixel_array = pixel_array - intercept
slope = np.amax(pixel_array)-np.amin(pixel_array)
slope = slope/65535.0
pixel_array = np.round(pixel_array/slope)
pixel_array = pixel_array.astype(np.uint16)
# Place data into slice
outvolume[z_i].RescaleSlope = slope
outvolume[z_i].RescaleIntercept = intercept
outvolume[z_i].PixelData = pixel_array.tostring()
outvolume[z_i].Columns = xdim
outvolume[z_i].Rows = ydim
outvolume[z_i].NumberOfSlices = zdim
outvolume[z_i].NumberOfTimeSlices = 1
outvolume[z_i].ImageIndex = z_i+1
# Create output directory if it does not exist
if not os.path.exists(out_dir):
os.makedirs(out_dir)
else:
shutil.rmtree(out_dir)
os.makedirs(out_dir)
# Write output DICOM
filenames = dcmio.WriteDICOM_frames(out_dir, [outvolume], 'IM')
out_dirs.append(out_dir)
return out_dirs
def DICOM2ASCII_ROI(in_dir, out_prefix, DICOMpath, bounds):
import dicom
import DicomIO
import bfitASCII_IO
import numpy as np
import os
import shutil
splitted = DICOMpath.split(os.sep)
outdir = outputASCIIdir + os.sep + splitted[-1] + '_' + in_dir + '_ASCII.txt'
print 'Output directory will be ' + outdir
if os.path.isfile(outdir):
os.remove(outdir)
# Resolve new frame list
dcmio = DicomIO.DicomIO()
print 'Reading ' + (experiment_dir + '/' + out_prefix + '/' + in_dir)
frame_list = dcmio.ReadDICOM_frames(experiment_dir + '/' + out_prefix + '/' + in_dir)
slice_1st = frame_list[0][0]
xdim = slice_1st.Columns
ydim = slice_1st.Rows
zdim = slice_1st.NumberOfSlices
tdim = slice_1st.NumberOfTimeSlices
print 'Dimensions:' + str((xdim, ydim, zdim, tdim))
offset = 0
subwindow_dimensions = [xdim-(2*offset), ydim-(2*offset), zdim, tdim]
subwindow = [bounds[0]+offset, bounds[0]+xdim-offset, bounds[2]+offset, bounds[2]+ydim-offset]
print "subwindow dimensions:" + str(subwindow_dimensions)
print "subwindow:" + str(subwindow)
# Load ROI mask data
print 'Reading ' + (experiment_dir + '/' + out_prefix + '/' + in_dir)
DICOM_ROIdata = dcmio.ReadDICOM_frames(DICOMpath)
ROIimg = DICOM_ROIdata[0]
ROIxdim = ROIimg[0].Columns
ROIydim = ROIimg[0].Rows
ROIzdim = ROIimg[0].NumberOfSlices
ROItdim = ROIimg[0].NumberOfTimeSlices
print 'ROI Dimensions:' + str((ROIxdim, ROIydim, ROIzdim, ROItdim))
ROImin, ROImax = np.min(ROIimg[11].pixel_array), np.max(ROIimg[11].pixel_array)
print str((ROImin, ROImax))
# Save in data in order z,y,x
SIs = []
ROIslice = []
for z_i in range(zdim):
slice = ROIimg[z_i].pixel_array.astype(float)
ROImin, ROImax = np.min(slice), np.max(slice)
non_zero = np.nonzero(slice)
for non_zero_xy_i in range(len(non_zero[0])):
y_i = non_zero[0][non_zero_xy_i]-subwindow[2]
x_i = non_zero[1][non_zero_xy_i]-subwindow[0]
if not (z_i+1) in ROIslice:
ROIslice.append(z_i+1)
SI = []
for t_i in range(tdim):
SI.append(frame_list[t_i][z_i].pixel_array[y_i, x_i] * frame_list[t_i][z_i].RescaleSlope + frame_list[t_i][z_i].RescaleIntercept)
SIs.append(SI)
print str(z_i+1) + '/' + str(zdim)
# Write data into ASCII file for fittings
name = (splitted[-1] + '_' + in_dir)
print 'Name:' + name
bset = []
for frame_i in range(len(frame_list)):
bset.append(int(frame_list[frame_i][9].FrameReferenceTime)/1000)
print 'Bset:' + str(bset)
print "total SIs:" + str(len(SIs))
ROI_No = 0
print 'ROI_No:' + str(ROI_No)
ROIslice.sort()
print 'ROIslice:' + str(ROIslice)
subwindow = [0, 0, 0, 0]
print 'Subwindow:' + str(subwindow)
data = { 'subwindow': subwindow, 'ROI_No': ROI_No, 'bset': bset, 'ROIslice': ROIslice, 'name': name, 'SIs': SIs }
ASCIIio = bfitASCII_IO.bfitASCII_IO()
print ("Writing " + outdir)
ASCIIio.Write3D(outdir, data)
return outdir
