def _run_interface(self, runtime):
if not isdefined(self.inputs.output_file):
self.inputs.output_file = self._gen_output(self.inputs.in_file,
self._suffix)
print self.inputs.in_file
print self.inputs.reference
header = self.inputs.header
pet = volumeFromFile(self.inputs.in_file)
reference = volumeFromFile(self.inputs.reference)
out = volumeLikeFile(self.inputs.reference, self.inputs.output_file)
ndim = len(pet.data.shape)
vol = pet.data
if ndim > 3:
try:
time_frames = [
float(s) for s, e in header['Time']["FrameTimes"]["Values"]
]
except ValueError:
time_frames = [1.]
vol = simps(pet.data, time_frames, axis=4)
idx = reference.data > 0
ref = np.mean(vol[idx])
print "SUVR Reference = ", ref
vol = vol / ref
out.data = vol
out.writeFile()
out.closeVolume()
return runtime
def distance(pet_fn, mri_fn, t1_brain_fn, pet_brain_fn, dist_f_list):
pet = pyminc.volumeFromFile(pet_fn)
mri = pyminc.volumeFromFile(mri_fn)
t1_mask = pyminc.volumeFromFile(t1_brain_fn)
pet_mask = pyminc.volumeFromFile(pet_brain_fn)
pet_data = pet.data.flatten()
mri_data = mri.data.flatten()
t1_mask_data = t1_mask.data.flatten()
pet_mask_data = pet_mask.data.flatten()
n = len(pet_data)
overlap = t1_mask_data * pet_mask_data
masked_pet_data = [pet_data[i] for i in range(n) if int(overlap[i]) == 1]
masked_mri_data = [mri_data[i] for i in range(n) if int(overlap[i]) == 1]
del pet
del mri
del t1_mask
del pet_mask
del t1_mask_data
del pet_mask_data
dist_list = []
for dist_f in dist_f_list:
dist_list.append(dist_f(masked_pet_data, masked_mri_data))
return (dist_list)
def getFinestResolution(inSource):
"""
This function will return the highest (or finest) resolution
present in the inSource file.
"""
imageResolution = []
if isFileHandler(inSource):
# make sure that pyminc does not complain about non-existing files. During the
# creation of the overall compute graph the following file might not exist. In
# that case, use the inputFileName, or raise an exception
if (isfile(inSource.getLastBasevol())):
imageResolution = volumeFromFile(
inSource.getLastBasevol()).separations
elif (isfile(inSource.inputFileName)):
imageResolution = volumeFromFile(
inSource.inputFileName).separations
else:
# neither the last base volume, nor the input file name exist at this point
# this could happen when we evaluate an average for instance
raise
else:
imageResolution = volumeFromFile(inSource).separations
# the abs function does not work on lists... so we have to loop over it. This
# to avoid issues with negative step sizes. Initialize with first dimension
finestRes = abs(imageResolution[0])
for i in range(1, len(imageResolution)):
if (abs(imageResolution[i]) < finestRes):
finestRes = abs(imageResolution[i])
return finestRes
def getFinestResolution(inSource):
"""
This function will return the highest (or finest) resolution
present in the inSource file.
"""
imageResolution = []
if isFileHandler(inSource):
# make sure that pyminc does not complain about non-existing files. During the
# creation of the overall compute graph the following file might not exist. In
# that case, use the inputFileName, or raise an exception
if(isfile(inSource.getLastBasevol())):
imageResolution = volumeFromFile(inSource.getLastBasevol()).separations
elif(isfile(inSource.inputFileName)):
imageResolution = volumeFromFile(inSource.inputFileName).separations
else:
# neither the last base volume, nor the input file name exist at this point
# this could happen when we evaluate an average for instance
raise
else:
imageResolution = volumeFromFile(inSource).separations
# the abs function does not work on lists... so we have to loop over it. This
# to avoid issues with negative step sizes. Initialize with first dimension
finestRes = abs(imageResolution[0])
for i in range(1, len(imageResolution)):
if(abs(imageResolution[i]) < finestRes):
finestRes = abs(imageResolution[i])
return finestRes
def _run_interface(self, runtime):
header = json.load(open(self.inputs.header, "r"))
if not isdefined(self.inputs.out_file):
self.inputs.out_file = self._gen_output(self.inputs.in_file,
self._suffix)
try:
dose = float(header["RadioChem"]["InjectedRadioactivity"])
except ValueError:
print(
"Error: Could not find injected dose in subject's header. Make sure subject has a .json header in BIDS format with [RadioChem][InjectedRadioactivity]"
)
exit(1)
try:
weight = float(header["Info"]["BodyWeight"])
except ValueError:
print(
"Error: Could not find subject's body weight in header. Make sure subject has a .json header in BIDS format with [Info][BodyWeight]"
)
exit(1)
pet = volumeFromFile(self.inputs.in_file)
reference = volumeFromFile(self.inputs.reference)
out = volumeLikeFile(self.inputs.reference, self.inputs.out_file)
ndim = len(pet.data.shape)
vol = pet.data
if ndim > 3:
dims = pet.getDimensionNames()
i = dims.index('time')
if not isdefined(self.inputs.start_time):
start_time = 0
else:
start_time = self.inputs.start_time
if not isdefined(self.inputs.end_time):
end_time = header['Time']['FrameTimes']['Values'][-1][1]
else:
end_time = self.inputs.end_time
#time_frames = time_indices = []
#for i in range(vol.shape[i]) :
# s=header['Time']["FrameTimes"]["Values"][i][0]
# e=header['Time']["FrameTimes"]["Values"][i][1]
# print(i)
# if s >= start_time and e <= end_time :
# time_indices.append(i)
# time_frames.append(float(e) - float(s) )
#print(time_indices)
#print(time_frames)
time_frames = [
float(s) for s, e in header['Time']["FrameTimes"]["Values"]
]
vol = simps(pet.data, time_frames, axis=i)
vol = vol / (dose / weight)
out.data = vol
out.writeFile()
out.closeVolume()
return runtime
def set_params(stage: CmdStage):
img_pyminc = pyminc.volumeFromFile(img.path)
ref_pyminc = pyminc.volumeFromFile(ref.path)
count = np.maximum(ref_pyminc.data.count, img_pyminc.data.count)
sum = ref_pyminc.data.count[0] + img_pyminc.data.count[0]
for index, arg in enumerate(stage.cmd):
stage.cmd[index] = arg.format(start='0,0,0,',
count='%s,%s,%s' %
(sum, count[1], count[2]))
def read_minc_image(minc_filename):
split = minc_filename.split(',')
minc_vol = pyminc.volumeFromFile(split[0])
vol = minc_vol.data
vol = np.expand_dims(vol, axis=0)
if (np.size(split) > 1):
for i in range(1, np.size(split)):
minc_vol = pyminc.volumeFromFile(split[i])
vol = np.concatenate((vol, np.expand_dims(minc_vol.data, axis=0)),
axis=0)
return vol
def _run_interface(self, runtime):
in_file = self.inputs.in_file
float_val = self.inputs.float_val
tol = self.inputs.tol
dim_to_interpolate = self.inputs.dim_to_interpolate
self.out_files = []
volume = volumeFromFile(in_file)
data = np.copy(volume.data)
volume.closeVolume()
data = select_structure(data, float_val, tol)
_, base, _ = split_filename(in_file)
assert dim_to_interpolate in [0, 1, 2]
assert len(data.shape) == 3
if dim_to_interpolate == 0:
slices = [data[i, :, :] for i in range(data.shape[0])]
elif dim_to_interpolate == 1:
slices = [data[:, i, :] for i in range(data.shape[1])]
elif dim_to_interpolate == 2:
slices = [data[:, :, i] for i in range(data.shape[2])]
for (i, s) in enumerate(slices):
fname = 'slice_%08d.npz' % i
np.savez_compressed(fname, s)
self.out_files.append(os.path.abspath(fname))
return runtime
def _run_interface(self, runtime):
in_files = self.inputs.in_files
labels = self.inputs.labels
self.out_file = os.path.abspath('merged.mnc')
v = volumeFromDescription(self.out_file,
self.inputs.dimension_names,
self.inputs.sizes,
self.inputs.starts,
self.inputs.separations,
volumeType='ubyte')
components = {}
for (i, lab) in enumerate(labels):
in_volume = volumeFromFile(in_files[i])
components[i] = np.copy(in_volume.data.astype('uint8'))
in_volume.closeVolume()
v.data += lab * components[
i] # FIXME We shouldn't be adding things here... or should we?
for i in range(len(labels)):
for j in range(i + 1, len(labels)):
assert not overlap(components[i], components[j])
v.writeFile()
v.closeVolume()
return runtime
def perfusion_volumes(perfusion_file, l):
cnt = 0
## nc_data_type=py_minc.NC_BYTE is writing a byte (floating point) but we want the voxel intensities to be int labels
## nc_data_type=py_minc.NC_SHORT is writing a short integer data and we want the voxel intensities to be int labels
#perfusion_pattern = py_minc.ArrayVolume(perfusion_file, nc_data_type=py_minc.NC_BYTE )# without this always [z,y,x], with ,dim_names=py_minc.FILE_ORDER_DIMENSION_NAMES order as the image
#sizes = perfusion_pattern.get_sizes()
#print sizes[0], sizes[1], sizes[2]
#spacing = perfusion_pattern.get_separations()
#print spacing[0], spacing[1], spacing[2]
perfusion_pattern = pymincf.volumeFromFile(perfusion_file,
dtype='ubyte') #ushort
perfusion_pattern.openFile()
sizes = perfusion_pattern.getSizes()
spacing = perfusion_pattern.getSeparations()
for z_vox in range(sizes[0]):
for y_vox in range(sizes[1]):
for x_vox in range(sizes[2]):
#if int(round(perfusion_pattern.array[z_vox,y_vox,x_vox]))==l:
if perfusion_pattern[z_vox, y_vox, x_vox] == l:
cnt += 1
#print cnt
perfusion_pattern.closeVolume()
return cnt * spacing[0] * spacing[1] * spacing[2]
def _parse_inputs(self, skip=None):
self.inputs.output_file = self.inputs.in_file #
header = self.inputs.header
if skip is None:
skip = []
data = json.load(open(header, "rb"))
vol = pyminc.volumeFromFile(self.inputs.in_file)
dims = vol.getDimensionNames()
if 'time' in dims:
#See if there is a start time defined, else set to 0
try:
data["time"]["start"][0]
self.inputs.tstart = data["time"]["start"][0]
except KeyError:
self.inputs.tstart = 0
try:
data["time"]["start"][0]
self.inputs.tstep = data["time"]["step"][0]
except KeyError:
self.inputs.tstep = 1
if not self.inputs.time_only:
self.inputs.zstart = data["zspace"]["start"][0]
self.inputs.ystart = data["yspace"]["start"][0]
self.inputs.xstart = data["xspace"]["start"][0]
self.inputs.zstep = data["zspace"]["step"][0]
self.inputs.ystep = data["yspace"]["step"][0]
self.inputs.xstep = data["xspace"]["step"][0]
return super(FixHeaderCommand, self)._parse_inputs(skip=skip)
def readFile(self):
"""Read the pixel data and dimensions from file."""
if self.file_type == 'minc':
self.minc = pyminc.volumeFromFile(self.file_path, labels=True)
self.nifti = None
self.pixdim = np.abs(np.array(self.minc.separations), dtype=float)
self.data = np.array(self.minc.data, dtype=int)
# MINC files apparently sometimes store the x, y, z dimensions in strange orders. Try to fix this such that the data and pixdim arrays are ordered (x, y, z)
desired_dimnames = ['xspace', 'yspace', 'zspace']
transpose_axes = [0, 0, 0] # generate 'axes' argument for numpy.transpose(), to rearrange the data.
if self.minc.dimnames != desired_dimnames:
# Reorder the pixdim and data arrays.
new_pixdim = np.zeros(shape=(3,), dtype=float)
for desired_index, desired_dimname in enumerate(desired_dimnames):
current_index = self.minc.dimnames.index(desired_dimname)
new_pixdim[desired_index] = self.pixdim[current_index]
transpose_axes[desired_index] = current_index
self.pixdim = new_pixdim
self.data = np.transpose(self.data, axes=transpose_axes)
elif self.file_type == 'nifti':
self.minc = None
self.nifti = nib.load(self.file_path)
self.pixdim = np.array(self.nifti.header['pixdim'][1:4], dtype=float)
self.data = np.array(self.nifti.get_fdata(), dtype=int)
# Combine unique labels if requested.
if self.combine_labels:
self.data[self.data != 0] = 1 # Set all nonzero values to 1.
def set_memory(st, mem_cfg):
# see comments re: mincblur memory configuration
voxels = reduce(mul, volumeFromFile(source.path).getSizes())
mem_per_voxel = (mem_cfg.mem_per_voxel_coarse
if 0 in conf.convergence.iterations[-1:] #-2?
# yikes ... this parsing should be done earlier
else mem_cfg.mem_per_voxel_fine)
st.setMem(mem_cfg.base_mem + voxels * mem_per_voxel)
def set_memory(st, source: MincAtom, conf: ANTSConf, mem_cfg):
# see comments re: mincblur memory configuration
voxels = reduce(mul, volumeFromFile(source.path).getSizes())
mem_per_voxel = (mem_cfg.mem_per_voxel_coarse
if int(conf.iterations.split('x')[-1]) == 0
# yikes ... this parsing should be done earlier
else mem_cfg.mem_per_voxel_fine)
st.setMem(mem_cfg.base_mem + voxels * mem_per_voxel)
def distance(pet_fn, mri_fn, t1_brain_fn, pet_brain_fn, dist_f_list):
pet = pyminc.volumeFromFile(pet_fn)
mri = pyminc.volumeFromFile(mri_fn)
t1_mask= pyminc.volumeFromFile(t1_brain_fn)
pet_mask= pyminc.volumeFromFile(pet_brain_fn)
pet_data=pet.data.flatten()
mri_data=mri.data.flatten()
t1_mask_data=t1_mask.data.flatten()
pet_mask_data=pet_mask.data.flatten()
if not pet.data.shape == mri.data.shape :
print("Dimension mismatch between pet and mri:")
print(pet_fn, pet_mask.data.shape)
print(mri_fn, t1_mask.data.shape)
exit(1)
if not t1_mask_data.shape == pet_mask_data.shape :
print("Dimension mismatch between masks pet and mri:")
print(pet_brain_fn, pet_mask.data.shape)
print(t1_brain_fn, t1_mask.data.shape)
exit(1)
overlap = t1_mask_data * pet_mask_data
overlap[ overlap >= 1 ] = 1
#temp_qc(np.array(pet.data), np.array(mri.data), np.array(t1_mask.data+pet_mask.data), pet_mask.data, os.path.basename(pet_fn)+'.png')
#print(pet_fn)
#print(mri_fn)
#print(t1_brain_fn)
#print(pet_brain_fn)
n=overlap.shape[0]
masked_pet_data = [ pet_data[i] for i in range(n) if int(overlap[i]) == 1 ]
masked_mri_data = [ mri_data[i] for i in range(n) if int(overlap[i]) == 1 ]
del pet
del mri
del t1_mask
del pet_mask
del t1_mask_data
del pet_mask_data
dist_list=[]
for dist_f in dist_f_list:
dist_list.append(dist_f(masked_pet_data, masked_mri_data))
return(dist_list)
def _run_interface(self, runtime):
if not isdefined(self.inputs.out_file):
self.inputs.out_file = self._gen_output(self.inputs.in_file,
self._suffix)
header = json.load(open(self.inputs.header, "r"))
pet = volumeFromFile(self.inputs.in_file)
reference = volumeFromFile(self.inputs.reference)
out = volumeLikeFile(self.inputs.reference, self.inputs.out_file)
ndim = len(pet.data.shape)
vol = pet.data
if ndim > 3:
dims = pet.getDimensionNames()
i = dims.index('time')
if not isdefined(self.inputs.start_time):
start_time = 0
else:
start_time = self.inputs.start_time
if not isdefined(self.inputs.end_time):
end_time = header['Time']['FrameTimes']['Values'][-1][1]
else:
end_time = self.inputs.end_time
try:
#time_frames = [ float(s) for s,e in header['Time']["FrameTimes"]["Values"] ]
time_frames = [
float(s) for s, e in header['Time']["FrameTimes"]["Values"]
if s >= start_time and e <= end_time
]
except ValueError:
time_frames = [1.]
vol = simps(pet.data, time_frames, axis=i)
idx = reference.data > 0
ref = np.mean(vol[idx])
print "SUVR Reference = ", ref
vol = vol / ref
out.data = vol
out.writeFile()
out.closeVolume()
return runtime
def set_memory(st, mem_cfg):
# see comments re: mincblur memory configuration
voxels = reduce(mul, volumeFromFile(source.path).getSizes())
mem_per_voxel = (
mem_cfg.mem_per_voxel_coarse
if 0 in conf.convergence.iterations[-1:] #-2?
# yikes ... this parsing should be done earlier
else mem_cfg.mem_per_voxel_fine)
st.setMem(mem_cfg.base_mem + voxels * mem_per_voxel)
def check_overlap((f_i, f_j,)):
data_i = volumeFromFile(f_i).data
data_j = volumeFromFile(f_j).data
data_i[np.where(data_i > 0)] = 1
data_j[np.where(data_j > 0)] = 1
data_i = data_i.astype('uint8')
data_j = data_j.astype('uint8')
for k in range(data_i.shape[1]):
if overlap(data_i[:, k, :], data_j[:, k, :]):
print (f_i, f_j)
return (f_i, f_j)
print f_i, f_j, None
return None
def set_memory(st, source: MincAtom, conf: ANTSConf, mem_cfg):
# see comments re: mincblur memory configuration
voxels = reduce(mul, volumeFromFile(source.path).getSizes())
mem_per_voxel = (
mem_cfg.mem_per_voxel_coarse
if int(conf.iterations.split('x')[-1]) == 0
# yikes ... this parsing should be done earlier
else mem_cfg.mem_per_voxel_fine)
st.setMem(mem_cfg.base_mem + voxels * mem_per_voxel)
def write_minc_image(array, example_image_filename, output_name):
in_vol = pyminc.volumeFromFile(example_image_filename)
out_vol = pyminc.volumeFromInstance(in_vol, output_name)
out_vol.data = np.squeeze(array)
out_vol.writeFile()
in_vol.closeVolume()
out_vol.closeVolume()
def getFinestResolution(inSource):
"""
This function will return the highest (or finest) resolution
present in the inSource file.
"""
imageResolution = []
if isFileHandler(inSource):
imageResolution = volumeFromFile(inSource.getLastBasevol()).separations
else:
imageResolution = volumeFromFile(inSource).separations
# the abs function does not work on lists... so we have to loop over it. This
# to avoid issues with negative step sizes. Initialize with first dimension
finestRes = abs(imageResolution[0])
for i in range(1, len(imageResolution)):
if(abs(imageResolution[i]) < finestRes):
finestRes = abs(imageResolution[i])
return finestRes
def get_nhdr_info(filename):
infile = pyminc.volumeFromFile(
filename
) # mincreshape -dimorder time,xspace,yspace,zspace dyn.mnc dyn_reorder.mnc -clobber
img = np.array(infile.data)
infile.closeVolume()
#b = b.flatten('F').reshape(20,192,192,35)
header = {}
header['type'] = infile.dtype
header['dimension'] = infile.ndims
header['space'] = 'right-anterior-superior' # Hardcoded!!
header['sizes'] = np.array(infile.data.shape)
header['endian'] = 'little'
header['encoding'] = 'gzip'
header['measurement frame'] = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
if infile.ndims == 4:
header['space directions'] = np.array([[np.nan, np.nan, np.nan],
[infile.separations[1], 0, 0],
[0, infile.separations[2], 0],
[0, 0, infile.separations[3]]])
header['kinds'] = ['list', 'domain', 'domain', 'domain']
header['space origin'] = np.array(
[infile.starts[1], infile.starts[2], infile.starts[3]])
TE = str(
float(
os.popen('mincinfo -attvalue acquisition:echo_time ' +
filename + ' -error_string noTE').read().rstrip()) *
1000)
header['MultiVolume.DICOM.EchoTime'] = TE
flip = str(
float(
os.popen('mincinfo -attvalue acquisition:flip_angle ' +
filename + ' -error_string noKVP').read().rstrip()))
header['MultiVolume.DICOM.FlipAngle'] = flip
TR = str(
float(
os.popen('mincinfo -attvalue acquisition:repetition_time ' +
filename + ' -error_string noKVP').read().rstrip()) *
1000)
header['MultiVolume.DICOM.RepetitionTime'] = TR
header['MultiVolume.FrameIdentifyingDICOMTagName'] = 'AcquisitionTime'
header['MultiVolume.FrameIdentifyingDICOMTagUnits'] = 'ms'
header[
'MultiVolume.FrameLabels'] = '0.0,7585.0,15167.5,22750.0,30332.5,37917.5,45500.0,53082.5,60665.0,68250.0,75832.5,83415.0,90997.5,98582.5,106165.0,113747.5,121330.0,128915.0,136497.5,144080.0,151662.5,159247.5,166830.0,174412.5,181995.0,189580.0,197162.5,204745.0,212327.5,219912.5,227495.0,235077.5,242660.0,250245.0,257827.5'
header['MultiVolume.NumberOfFrames'] = '35'
if infile.ndims == 3:
header['space directions'] = np.array([[infile.separations[0], 0, 0],
[0, infile.separations[1], 0],
[0, 0, infile.separations[2]]])
header['kinds'] = ['domain', 'domain', 'domain']
header['space origin'] = np.array(
[infile.starts[0], infile.starts[1], infile.starts[2]])
return img, header
def get_mask_list(sourceDir, ROIMask):
gen = os.walk(sourceDir)
for dirName, subdirList, fileList in gen:
for f in fileList:
if ROIMask[0] in f:
#Load in volume and get unique values
mask = pyminc.volumeFromFile(dirName + os.sep + f)
mask_flat = mask.data.flatten()
label = [str(int(round(i))) for i in np.unique(mask_flat)]
if 0 in label: label.remove(0)
return (label)
return ([1])
def pvc_mse(pvc_fn, pve_fn, fwhm):
pvc = pyminc.volumeFromFile(pvc_fn)
pve = pyminc.volumeFromFile(pve_fn)
mse = 0
if len(pvc.data.shape) > 3: #if volume has more than 3 dimensions
t = int(pvc.sizes[0] / 2)
#for t in range(pvc.sizes[0]):
pve_frame = pve.data[t, :, :, :]
pvc_frame = pvc.data[t, :, :, :]
n = np.sum(pve.data[t, :, :, :]) # np.prod(pve.data.shape[0:4])
pvc_blur = gaussian_filter(pvc_frame, fwhm)
m = np.sum(np.sqrt((pve_frame - pvc_blur)**2))
mse += m
print t, m
else: #volume has 3 dimensions
n = np.sum(pve.data) # np.prod(pve.data.shape[0:3])
pvc_blur = gaussian_filter(pvc.data, fwhm)
m = np.sum(np.sqrt((pve.data - pvc_blur)**2))
mse += m
mse = -mse / n #np.sum(pve.data)
print("PVC MSE:", mse)
return mse
def __init__(self, filesToResample, resolution):
"""During initialization make sure all files are resampled
at resolution we'd like to use for each pipeline stage
"""
self.p = Pipeline()
for FH in filesToResample:
dirForOutput = self.getOutputDirectory(FH)
currentRes = volumeFromFile(FH.getLastBasevol()).separations
if not abs(abs(currentRes[0]) - abs(resolution)) < 0.01:
crop = ma.autocrop(resolution, FH, defaultDir=dirForOutput)
self.p.addStage(crop)
mask = FH.getMask()
if mask:
#Need to resample the mask as well.
cropMask = ma.mincresampleMask(FH,
FH,
outputLocation=FH,
likeFile=FH)
self.p.addStage(cropMask)
def __init__(self, filesToResample, resolution):
"""During initialization make sure all files are resampled
at resolution we'd like to use for each pipeline stage
"""
self.p = Pipeline()
for FH in filesToResample:
dirForOutput = self.getOutputDirectory(FH)
currentRes = volumeFromFile(FH.getLastBasevol()).separations
if not abs(abs(currentRes[0]) - abs(resolution)) < 0.01:
crop = ma.autocrop(resolution, FH, defaultDir=dirForOutput)
self.p.addStage(crop)
mask = FH.getMask()
if mask:
#Need to resample the mask as well.
cropMask = ma.mincresampleMask(FH,
FH,
outputLocation=FH,
likeFile=FH)
self.p.addStage(cropMask)
def do_component(component_nr):
input_volume = volumeFromFile(
'/scratch/intersection_output_disjoint/input_%d.mnc' % component_nr)
output_volume = volumeLikeFile(
'/scratch/intersection_output_disjoint/input_%d.mnc' % component_nr,
'/scratch/final_smoothed_disjoint_components/component_%d.mnc' %
component_nr,
dtype='ubyte')
for j in range(input_volume.data.shape[1]):
print component_nr, j
output_volume.data[:, j, :] = blerp(input_volume.data[:, j, :])
output_volume.writeFile()
output_volume.closeVolume()
input_volume.closeVolume()
"""
def load_2D_mnc(self, filename):
"""loads and squeezes a 2D mncfile"""
import pyminc.volumes.factory as pyminc
mncfile = pyminc.volumeFromFile(filename)
array_data = np.squeeze(np.array(mncfile.data))
return array_data
# Standard modules
import os, sys
#import argparse
# Non-standard modules
import numpy as np
import pyminc.volumes.factory as pyminc
# My modules in other directories
sufkes_git_repo_dir = "/Users/steven ufkes/scripts" # change this to the path to which the sufkes Git repository was cloned.
sys.path.append(os.path.join(sufkes_git_repo_dir, "misc"))
from Color import Color
minc_file_path = str(sys.argv[1])
minc_vol = pyminc.volumeFromFile(minc_file_path, labels=True)
separations = minc_vol.separations
volume = minc_vol.data
def getVolumeSet(volume, val_list):
"""Separate a single volume into multiple volumes of the same size
by sorting voxels into groups based on the number assigned to them.
For example, suppose you labelled right-hemisphere lesions with '1'
and left-hemisphere lesions with '2', this function will return a
list of 2 volumes, each with the original size. One will contain all
zeros except for the voxels labelled '1'; the other will contain all
zeros except for the voxels labelled '2'.
This function will also convert all the labels to the int type by
rounding to the nearest integer."""
volume_list = [
def load_minc_as_np(mncfile):
print(mncfile)
_img = pyminc.volumeFromFile(mncfile)
img = np.array(_img.data,dtype='double')
_img.closeVolume()
return img
#g= graph_analysis.input_graph(input_file)
##g= graph_analysis.input_graph("/micehome/sghanavati/Documents/data/journal1data_c57_feb13/LOO_final_revised/autolabel_c57_1_4_S_cyl.db")
##g= graph_analysis.input_graph("./c57_1_9Nov12/c57_1_graph_add_coverage_delleave_radi1.06_smooth2_simplified_rmisolate_features_groundtruthlabel_cyl_revised.db")
#mr_atlas_file = "/projects/souris/sghanavati/data/c57_male_female_mri_atlas/c57_brain_segmentation_mnc2_merged_reg2vascular.mnc"
###mr_atlas_file = "/projects/souris/sghanavati/data/c57_male_female_mri_atlas/c57_brain_segmentation_mnc2_merged_reg2vascular_downsample_merge.mnc"
###labels = [2,43,102,143,122,8,5,108,105,35,135,13,236,111,191,190,91,90,200,9,7,10,196,96,198,68,227,168,169,46,12,49,45,14,15,17,18,3,4]
#labels = [122, 8, 5, 108, 105, 35, 135, 13, 236, 111, 191, 190, 91, 90, 68, 227, 168, 169, 46, 12, 49, 45, 14, 15, 17, 18, 3, 4]
labels = {}
#perfusion_pattern = py_minc.ArrayVolume(perfusion_file, nc_data_type=py_minc.NC_BYTE)# without this always [z,y,x], with ,dim_names=py_minc.FILE_ORDER_DIMENSION_NAMES order as the image
#sizes = perfusion_pattern.get_sizes()
#spacing = perfusion_pattern.get_separations()
perfusion_pattern = pymincf.volumeFromFile(perfusion_file,
dtype='ubyte') #ushort
perfusion_pattern.openFile()
sizes = perfusion_pattern.getSizes()
spacing = perfusion_pattern.getSeparations()
#print sizes[0], sizes[1], sizes[2],":",spacing[0],spacing[1],spacing[2]
for z_vox in range(sizes[0]):
for y_vox in range(sizes[1]):
for x_vox in range(sizes[2]):
value = perfusion_pattern[z_vox, y_vox, x_vox]
#value = int(round(perfusion_pattern.array[z_vox,y_vox,x_vox]))
if value > 0:
if value not in labels.keys():
labels[value] = 1
else:
labels[value] += 1
print labels.keys()
def perfusion_region_noremap(g,
mr_atlas_file,
labels,
perfusion_file,
Perfusionradius=1e10):
# mr_atlas_file = "/projects/souris/sghanavati/data/c57_male_female_mri_atlas/c57_brain_segmentation_mnc2_merged_reg2vascular.mnc"
# mr_atlas_file = "/projects/souris/sghanavati/data/c57_male_female_mri_atlas/c57_brain_segmentation_mnc2_merged_reg2vascular_downsample_merge.mnc"
endpoint = []
vpoint = []
for e in g.edge_list():
#if len(find_neighbor_edges(g,e))==2 and g.edge_property(e,'label') in labels:
if g.edge_property(e, 'label') in labels:
if len(g.vertices[e[0]].edges) == 1:
vpoint.append(e[0])
endpoint.append(e)
elif len(g.vertices[e[1]].edges) == 1:
vpoint.append(e[1])
endpoint.append(e)
#### mri_distance feature:
## nc_data_type=py_minc.NC_BYTE is writing a byte (floating point) but we want the voxel intensities to be int labels
## nc_data_type=py_minc.NC_SHORT is writing a short integer data and we want the voxel intensities to be int labels
#mri_atlas = py_minc.ArrayVolume(mr_atlas_file, nc_data_type=py_minc.NC_BYTE )# without this always [z,y,x], with ,dim_names=py_minc.FILE_ORDER_DIMENSION_NAMES order as the image
#perfusion_pattern = py_minc.ArrayVolume(mr_atlas_file, nc_data_type=py_minc.NC_BYTE )# without this always [z,y,x], with ,dim_names=py_minc.FILE_ORDER_DIMENSION_NAMES order as the image
#sizes = mri_atlas.get_sizes()
mri_atlas = pymincf.volumeFromFile(mr_atlas_file, dtype='ubyte') #ushort
mri_atlas.openFile()
sizes = mri_atlas.getSizes()
spacing = mri_atlas.getSeparations()
perfusion_pattern = pymincf.volumeFromInstance(mri_atlas,
perfusion_file,
dtype="ubyte") #ushort
#make all voxels 0, give label for vpoints
for z_vox in range(sizes[0]):
for y_vox in range(sizes[1]):
for x_vox in range(sizes[2]):
#perfusion_pattern.array[z_vox,y_vox,x_vox]=0
perfusion_pattern.data[z_vox, y_vox, x_vox] = 0
for i in range(len(vpoint)):
v = vpoint[i]
world = g.vertices[v].centre
#voxel = floor(mri_atlas.convert_world_to_voxel(array([world[0],world[1],world[2]])))
voxel = floor(
mri_atlas.convertWorldToVoxel(
np.array([world[0], world[1], world[2]])))
if voxel[0] in range(sizes[0]) and voxel[1] in range(
sizes[1]) and voxel[2] in range(sizes[2]):
perfusion_pattern.data[int(voxel[0]),
int(voxel[1]),
int(voxel[2])] = g.edge_property(
endpoint[i], 'label')
#perfusion_pattern.array[int(voxel[0]),int(voxel[1]),int(voxel[2])] = g.edge_property(endpoint[i],'label')
for z_vox in range(sizes[0]):
for y_vox in range(sizes[1]):
for x_vox in range(sizes[2]):
#world=mri_atlas.convert_voxel_to_world(array([z_vox,y_vox,x_vox]))
world = mri_atlas.convertVoxelToWorld(
np.array([z_vox, y_vox, x_vox]))
min_dist = 1e10
min_label = 0
for i in range(len(vpoint)):
v = vpoint[i]
if distance(world, g.vertices[v].centre
) < Perfusionradius and distance(
world, g.vertices[v].centre) < min_dist:
min_dist = distance(world, g.vertices[v].centre)
min_label = g.edge_property(endpoint[i], 'label')
#perfusion_pattern.array[z_vox,y_vox,x_vox]= int(min_label)
perfusion_pattern.data[z_vox, y_vox, x_vox] = int(min_label)
#perfusion_pattern.output(perfusion_file)
perfusion_pattern.writeFile()
perfusion_pattern.closeVolume()
mri_atlas.closeVolume()
parser.add_argument('RTMINC', help='Path to the OUTPUT MINC RT file')
parser.add_argument("--verbose", help="increase output verbosity", action="store_true")
parser.add_argument("--visualize", help="Show plot of slices for debugging", action="store_true")
parser.add_argument("--copy_name", help="Copy the name of the RTstruct (defined in Mirada) to the name of the MNC file", action="store_true")
args = parser.parse_args()
try:
RTSS = dicom.read_file(args.RTX)
print RTSS.StructureSetROISequence[0].ROIName
ROIs = RTSS.ROIContourSequence
if args.verbose:
print "Found",len(ROIs),"ROIs"
volume = pyminc.volumeFromFile(args.MINC)
for ROI_id,ROI in enumerate(ROIs):
# Create one MNC output file per ROI
RTMINC_outname = args.RTMINC if len(ROIs) == 1 else args.RTMINC[:-4] + "_" + str(ROI_id) + ".mnc"
RTMINC = pyminc.volumeLikeFile(args.MINC,RTMINC_outname)
contour_sequences = ROI.ContourSequence
if args.verbose:
print " --> Found",len(contour_sequences),"contour sequences for ROI:",RTSS.StructureSetROISequence[ROI_id].ROIName
for contour in contour_sequences:
assert contour.ContourGeometricType == "CLOSED_PLANAR"
current_slice_i_print = 0
def go(component_index):
# Top-level parameters:
input_file = '/mnt/home/carlo/00-init-label-vol.mnc'
dim_to_interpolate = 1
nr_interpolation_steps = 3
workflow_name = 'morpho_%d' % component_index
################
input_file = os.path.abspath(input_file)
volume = volumeFromFile(input_file)
data = volume.data
volume_dimnames = volume.dimnames
volume_starts = volume.starts
assert len(data.shape) == 3
assert dim_to_interpolate in [0, 1, 2]
assert nr_interpolation_steps >= 1
old_separations = volume.separations
new_separations = old_separations[:]
new_separations[dim_to_interpolate] /= 2**nr_interpolation_steps
new_sizes = volume.sizes[:3]
for s in new_sizes:
assert s > 0
new_sizes[dim_to_interpolate] = calc_new_sizes(
new_sizes[dim_to_interpolate], nr_interpolation_steps)
volume.closeVolume()
workflow = pe.Workflow(name=workflow_name)
cs = sorted(uniq(data.flatten()))
assert cs[0] == 0
cs = cs[1:]
# cs = cs[21:][:2] # FIXME Just for testing...
cs = [cs[component_index]]
extractors = []
minc_sink = {}
for c in cs:
slice_name = ('feature_%0.4f' % c).replace('.', '_')
print 'building workflow for:', slice_name
extract_node = pe.Node(interface=ExtractFeature(
in_file=input_file,
float_val=c,
tol=0.5,
dim_to_interpolate=dim_to_interpolate),
name='extract_feature_' + slice_name)
extractors.append(extract_node)
slice_size = data.shape[dim_to_interpolate]
minc_sink[slice_name] = build_workflow(
workflow, extract_node, slice_name, slice_size, dim_to_interpolate,
volume_dimnames, nr_interpolation_steps, volume_starts,
new_separations, new_sizes)
merge_minc_names = pe.Node(interface=Merge(len(minc_sink)),
name='merge_minc_names')
for (i, minc) in enumerate(minc_sink.itervalues()):
workflow.connect(minc, 'out_file', merge_minc_names, 'in%d' % (i + 1))
actual_final_merge = pe.Node(interface=MergeMincs(),
name='actual_final_merge_mincs')
workflow.connect(merge_minc_names, 'out', actual_final_merge, 'in_files')
actual_final_merge.inputs.labels = map(float, cs)
actual_final_merge.inputs.dimension_names = volume_dimnames
actual_final_merge.inputs.sizes = new_sizes
actual_final_merge.inputs.starts = volume_starts
actual_final_merge.inputs.separations = new_separations
merged_minc_sink = pe.Node(interface=nio.DataSink(),
name='merged_minc_sink')
workflow.connect(actual_final_merge, 'out_file', merged_minc_sink,
'merged_minc_file')
# FIXME Hardcoded...
# os.system('rm -fr /tmp/tmp_carlo')
# os.system('mkdir /tmp/tmp_carlo')
# workflow.base_dir = '/scratch/morph_debug'
#workflow.base_dir = '/scratch/init_00_morph'
# workflow.run()
workflow.run(plugin='MultiProc', plugin_args={'n_procs': 4})
def perfusion_region_nomask(g,
mr_atlas_file,
labels,
label_remap,
perfusion_file,
Perfusionradius=1e10):
# mr_atlas_file = "/projects/souris/sghanavati/data/c57_male_female_mri_atlas/c57_brain_segmentation_mnc2_merged_reg2vascular.mnc"
# mr_atlas_file = "/projects/souris/sghanavati/data/c57_male_female_mri_atlas/c57_brain_segmentation_mnc2_merged_reg2vascular_downsample_merge.mnc"
if label_remap:
lpairs = label_remap.split(',')
labelpairs = []
for pair in lpairs:
plabels = pair.split(':')
plabels = [int(l) for l in plabels]
labelpairs.append(plabels)
tomap_l = [int(l[0]) for l in labelpairs]
print labelpairs
for e in g.edge_list():
if g.edge_property(e, 'label') in tomap_l:
g.set_edge_property(
e, 'label',
int(labelpairs[tomap_l.index(g.edge_property(
e, 'label'))][1]))
endpoint = []
vpoint = []
for e in g.edge_list():
#if len(find_neighbor_edges(g,e))==2 and g.edge_property(e,'label') in labels:
if g.edge_property(e, 'label') in labels:
if len(g.vertices[e[0]].edges) == 1:
vpoint.append(e[0])
endpoint.append(e)
elif len(g.vertices[e[1]].edges) == 1:
vpoint.append(e[1])
endpoint.append(e)
if not len(vpoint) == len(endpoint):
print "ERROR: The length of endpoints and leaf edges should match but they don't!"
exit(0)
#### mri_distance feature:
## nc_data_type=py_minc.NC_BYTE is writing a byte (floating point) but we want the voxel intensities to be int labels
## nc_data_type=py_minc.NC_SHORT is writing a short integer data and we want the voxel intensities to be int labels
#mri_atlas = py_minc.ArrayVolume(mr_atlas_file, nc_data_type=py_minc.NC_BYTE )# without this always [z,y,x], with ,dim_names=py_minc.FILE_ORDER_DIMENSION_NAMES order as the image
#perfusion_pattern = py_minc.ArrayVolume(mr_atlas_file, nc_data_type=py_minc.NC_BYTE )# without this always [z,y,x], with ,dim_names=py_minc.FILE_ORDER_DIMENSION_NAMES order as the image
#sizes = mri_atlas.get_sizes()
mri_atlas = pymincf.volumeFromFile(mr_atlas_file, dtype='ubyte') #ushort
mri_atlas.openFile()
sizes = mri_atlas.getSizes()
spacing = mri_atlas.getSeparations()
perfusion_pattern = pymincf.volumeFromInstance(mri_atlas,
perfusion_file,
dtype="ubyte")
#make all voxels 0, give label for vpoints
for z_vox in range(sizes[0]):
for y_vox in range(sizes[1]):
for x_vox in range(sizes[2]):
label_dist = {l: Perfusionradius for l in labels}
#world = mri_atlas.convert_voxel_to_world(array([z_vox,y_vox,x_vox]))
world = mri_atlas.convertVoxelToWorld(
np.array([z_vox, y_vox, x_vox]))
for i in range(len(vpoint)):
v = vpoint[i]
l = g.edge_property(endpoint[i], 'label')
d = distance(world, g.vertices[v].centre)
if d < label_dist[l]:
label_dist[l] = d
label_dist_sorted = sorted(
label_dist.items(), key=operator.itemgetter(1)
) #### sort dictionary by value: result list of tuples #### sorted(label_dist.items(), key=operator.itemgetter(0)) ##sort dictionary by key
#perfusion_pattern.array[z_vox,y_vox,x_vox] = int(round(label_dist_sorted[0][0]))
perfusion_pattern.data[z_vox, y_vox, x_vox] = int(
round(label_dist_sorted[0][0]))
#perfusion_pattern.output(perfusion_file)
perfusion_pattern.writeFile()
perfusion_pattern.closeVolume()
mri_atlas.closeVolume()
