def main():
parser = getParser()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# loading input images
img, hdr = load(args.input)
img = img.astype(numpy.bool)
# check spacing values
if not len(args.spacing) == img.ndim:
parser.error(
'The image has {} dimensions, but {} spacing parameters have been supplied.'
.format(img.ndim, len(args.spacing)))
# check if output image exists
if not args.force:
if os.path.exists(args.output):
parser.error('The output image {} already exists.'.format(
args.output))
logger.debug('target voxel spacing: {}'.format(args.spacing))
# determine number of required complete slices for up-sampling
vs = header.get_pixel_spacing(hdr)
rcss = [
int(y // x - 1) for x, y in zip(args.spacing, vs)
] # TODO: For option b, remove the - 1; better: no option b, since I am rounding later anyway
# remove negatives and round up to next even number
rcss = [x if x > 0 else 0 for x in rcss]
rcss = [x if 0 == x % 2 else x + 1 for x in rcss]
logger.debug('intermediate slices to add per dimension: {}'.format(rcss))
# for each dimension requiring up-sampling, from the highest down, perform shape based slice interpolation
logger.info('Adding required slices using shape based interpolation.')
for dim, rcs in enumerate(rcss):
if rcs > 0:
logger.debug(
'adding {} intermediate slices to dimension {}'.format(
rcs, dim))
img = shape_based_slice_interpolation(img, dim, rcs)
logger.debug('resulting new image shape: {}'.format(img.shape))
# compute and set new voxel spacing
nvs = [x / (y + 1.) for x, y in zip(vs, rcss)]
header.set_pixel_spacing(hdr, nvs)
logger.debug('intermediate voxel spacing: {}'.format(nvs))
# interpolate with nearest neighbour
logger.info('Re-sampling the image with a b-spline order of {}.'.format(
args.order))
img, hdr = resample(img, hdr, args.spacing, args.order, mode='nearest')
# saving the resulting image
save(img, args.output, hdr, args.force)
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input image
data_input, header_input = load(args.input)
# transform to uin8
data_input = data_input.astype(scipy.uint8)
# reduce to 3D, if larger dimensionality
if data_input.ndim > 3:
for _ in range(data_input.ndim - 3): data_input = data_input[...,0]
# iter over slices (2D) until first with content is detected
for plane in data_input:
if scipy.any(plane):
# set pixel spacing
spacing = list(header.get_pixel_spacing(header_input))
spacing = spacing[1:3]
__update_header_from_array_nibabel(header_input, plane)
header.set_pixel_spacing(header_input, spacing)
# save image
save(plane, args.output, header_input, args.force)
break
logger.info("Successfully terminated.")
def zoom(image, factor, dimension, hdr = False, order = 3):
"""
Zooms the provided image by the supplied factor in the supplied dimension.
The factor is an integer determining how many slices should be put between each
existing pair.
If an image header (hdr) is supplied, its voxel spacing gets updated.
Returns the image and the updated header or false.
"""
# check if supplied dimension is valid
if dimension >= image.ndim:
raise argparse.ArgumentError('The supplied zoom-dimension {} exceeds the image dimensionality of 0 to {}.'.format(dimension, image.ndim - 1))
# get logger
logger = Logger.getInstance()
logger.debug('Old shape = {}.'.format(image.shape))
# perform the zoom
zoom = [1] * image.ndim
zoom[dimension] = (image.shape[dimension] + (image.shape[dimension] - 1) * factor) / float(image.shape[dimension])
logger.debug('Reshaping with = {}.'.format(zoom))
image = interpolation.zoom(image, zoom, order=order)
logger.debug('New shape = {}.'.format(image.shape))
if hdr:
new_spacing = list(header.get_pixel_spacing(hdr))
new_spacing[dimension] = new_spacing[dimension] / float(factor + 1)
logger.debug('Setting pixel spacing from {} to {}....'.format(header.get_pixel_spacing(hdr), new_spacing))
header.set_pixel_spacing(hdr, tuple(new_spacing))
return image, hdr
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input image
data_input, header_input = load(args.input)
logger.debug('Original shape = {}.'.format(data_input.shape))
# check if supplied dimension parameters is inside the images dimensions
if args.dimension1 >= data_input.ndim or args.dimension1 < 0:
raise ArgumentError('The first swap-dimension {} exceeds the number of input volume dimensions {}.'.format(args.dimension1, data_input.ndim))
elif args.dimension2 >= data_input.ndim or args.dimension2 < 0:
raise ArgumentError('The second swap-dimension {} exceeds the number of input volume dimensions {}.'.format(args.dimension2, data_input.ndim))
# swap axes
data_output = scipy.swapaxes(data_input, args.dimension1, args.dimension2)
# swap pixel spacing and offset
ps = list(header.get_pixel_spacing(header_input))
ps[args.dimension1], ps[args.dimension2] = ps[args.dimension2], ps[args.dimension1]
header.set_pixel_spacing(header_input, ps)
os = list(header.get_offset(header_input))
os[args.dimension1], os[args.dimension2] = os[args.dimension2], os[args.dimension1]
header.set_offset(header_input, os)
logger.debug('Resulting shape = {}.'.format(data_output.shape))
# save resulting volume
save(data_output, args.output, header_input, args.force)
logger.info("Successfully terminated.")
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input image
data_input, header_input = load(args.input)
# transform to uin8
data_input = data_input.astype(scipy.uint8)
# reduce to 3D, if larger dimensionality
if data_input.ndim > 3:
for _ in range(data_input.ndim - 3): data_input = data_input[...,0]
# iter over slices (2D) until first with content is detected
for plane in data_input:
if scipy.any(plane):
# set pixel spacing
spacing = list(header.get_pixel_spacing(header_input))
spacing = spacing[1:3]
__update_header_from_array_nibabel(header_input, plane)
header.set_pixel_spacing(header_input, spacing)
# save image
save(plane, args.output, header_input, args.force)
break
logger.info("Successfully terminated.")
def resample(img, hdr, target_spacing, bspline_order=3, mode='constant'):
"""
Re-sample an image to a new voxel-spacing. Taken form medpy.io.
Parameters
----------
img : array_like
The image.
hdr : object
The image header.
target_spacing : number or sequence of numbers
The target voxel spacing to achieve. If a single number, isotropic spacing is assumed.
bspline_order : int
The bspline order used for interpolation.
mode : str
Points outside the boundaries of the input are filled according to the given mode ('constant', 'nearest', 'reflect' or 'wrap'). Default is 'constant'.
Warning
-------
Voxel-spacing of input header will be modified in-place! If the target spacing can't be set exactly, for example in low pixel images, then the closest spacing will be chosen
Returns
-------
img : ndarray
The re-sampled image.
hdr : object
The image header with the new voxel spacing.
"""
if isinstance(target_spacing, numbers.Number):
target_spacing = [target_spacing] * img.ndim
# compute zoom values
zoom_factors = [old / float(new) for new, old in zip(target_spacing, header.get_pixel_spacing(hdr))]
print "Zoom Factors"
print zoom_factors
oldImageShape = img.shape
# zoom image
img = zoom(img, zoom_factors, order=bspline_order, mode=mode)
newImageShape = img.shape
old_pixel_spacing = header.get_pixel_spacing(hdr)
new_pixel_spacing = np.round(np.divide(np.multiply(oldImageShape,old_pixel_spacing),newImageShape),7)
print "Target Pixel Spacing"
print target_spacing
print "Actual Pixel Spacing"
print new_pixel_spacing
# set new voxel spacing
header.set_pixel_spacing(hdr, new_pixel_spacing)
return img, hdr
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input data
input_data, input_header = load(args.input)
logger.debug('Old shape = {}.'.format(input_data.shape))
# compute new shape
new_shape = list(input_data.shape)
new_shape[args.dimension] = 1 + (new_shape[args.dimension] -
1) / (args.discard + 1)
# prepare output image
output_data = scipy.zeros(new_shape, dtype=input_data.dtype)
# prepare slicers
slicer_in = [slice(None)] * input_data.ndim
slicer_out = [slice(None)] * input_data.ndim
# prepare skip-counter and output image slice counter
skipc = 0
slicec = 0
logger.debug('Shrinking from {} to {}...'.format(input_data.shape,
new_shape))
for idx in range(input_data.shape[args.dimension]):
if 0 == skipc:
# transfer slice
slicer_in[args.dimension] = slice(idx, idx + 1)
slicer_out[args.dimension] = slice(slicec, slicec + 1)
output_data[slicer_out] = input_data[slicer_in]
# resert resp. increase counter
skipc = args.discard
slicec += 1
else: # skip slice
# decrease skip counter
skipc -= 1
# set new pixel spacing
new_spacing = list(header.get_pixel_spacing(input_header))
new_spacing[
args.dimension] = new_spacing[args.dimension] * float(args.discard + 1)
logger.debug('Setting pixel spacing from {} to {}....'.format(
header.get_pixel_spacing(input_header), new_spacing))
header.set_pixel_spacing(input_header, tuple(new_spacing))
save(output_data, args.output, input_header, args.force)
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load first input image as example
example_data, example_header = load(args.inputs[0])
# test if the supplied position is valid
if args.position > example_data.ndim or args.position < 0:
raise ArgumentError('The supplied position for the new dimension is invalid. It has to be between 0 and {}.'.format(example_data.ndim))
# prepare empty output volume
output_data = scipy.zeros([len(args.inputs)] + list(example_data.shape), dtype=example_data.dtype)
# add first image to output volume
output_data[0] = example_data
# load input images and add to output volume
for idx, image in enumerate(args.inputs[1:]):
image_data, _ = load(image)
if not args.ignore and image_data.dtype != example_data.dtype:
raise ArgumentError('The dtype {} of image {} differs from the one of the first image {}, which is {}.'.format(image_data.dtype, image, args.inputs[0], example_data.dtype))
if image_data.shape != example_data.shape:
raise ArgumentError('The shape {} of image {} differs from the one of the first image {}, which is {}.'.format(image_data.shape, image, args.inputs[0], example_data.shape))
output_data[idx + 1] = image_data
# move new dimension to the end or to target position
for dim in range(output_data.ndim - 1):
if dim >= args.position: break
output_data = scipy.swapaxes(output_data, dim, dim + 1)
# set pixel spacing
spacing = list(header.get_pixel_spacing(example_header))
spacing = tuple(spacing[:args.position] + [args.spacing] + spacing[args.position:])
# !TODO: Find a way to enable this also for PyDicom and ITK images
if __is_header_nibabel(example_header):
__update_header_from_array_nibabel(example_header, output_data)
header.set_pixel_spacing(example_header, spacing)
else:
raise ArgumentError("Sorry. Setting the voxel spacing of the new dimension only works with NIfTI images. See the description of this program for more details.")
# save created volume
save(output_data, args.output, example_header, args.force)
logger.info("Successfully terminated.")
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input data
input_data, input_header = load(args.input)
logger.debug('Old shape = {}.'.format(input_data.shape))
# compute new shape
new_shape = list(input_data.shape)
new_shape[args.dimension] = 1 + (new_shape[args.dimension] - 1) / (args.discard + 1)
# prepare output image
output_data = scipy.zeros(new_shape, dtype=input_data.dtype)
# prepare slicers
slicer_in = [slice(None)] * input_data.ndim
slicer_out = [slice(None)] * input_data.ndim
# prepare skip-counter and output image slice counter
skipc = 0
slicec = 0
logger.debug('Shrinking from {} to {}...'.format(input_data.shape, new_shape))
for idx in range(input_data.shape[args.dimension]):
if 0 == skipc:
# transfer slice
slicer_in[args.dimension] = slice(idx, idx + 1)
slicer_out[args.dimension] = slice(slicec, slicec + 1)
output_data[slicer_out] = input_data[slicer_in]
# resert resp. increase counter
skipc = args.discard
slicec += 1
else: # skip slice
# decrease skip counter
skipc -= 1
# set new pixel spacing
new_spacing = list(header.get_pixel_spacing(input_header))
new_spacing[args.dimension] = new_spacing[args.dimension] * float(args.discard + 1)
logger.debug('Setting pixel spacing from {} to {}....'.format(header.get_pixel_spacing(input_header), new_spacing))
header.set_pixel_spacing(input_header, tuple(new_spacing))
save(output_data, args.output, input_header, args.force)
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# copy the example image or generate empty image, depending on the modus
if args.example:
grid_image = scipy.zeros(args.example_image.shape, scipy.bool_)
grid_header = args.example_header
else:
grid_image = scipy.zeros(args.shape, scipy.bool_)
# !TODO: Find another solution for this
# Saving and loading image once to generate a valid header
tmp_dir = tempfile.mkdtemp()
tmp_image = '{}/{}'.format(tmp_dir, args.output.split('/')[-1])
save(grid_image, tmp_image)
_, grid_header = load(tmp_image)
try:
os.remove(tmp_image)
os.rmdir(tmp_dir)
except Exception:
pass
# set the image attributes if supplied
if args.pixelspacing:
header.set_pixel_spacing(grid_header, args.pixelspacing)
if args.offset:
header.set_offset(grid_header, args.offset)
# compute the right grid spacing for each dimension
if args.real:
grid_spacing = [
int(round(sp / float(ps))) for sp, ps in zip(
args.spacing, header.get_pixel_spacing(grid_header))
]
else:
grid_spacing = args.spacing
# paint the grid into the empty image volume
for dim in range(grid_image.ndim):
if 0 == grid_spacing[dim]:
continue # skip dimension of 0 grid spacing supplied
for offset in range(0, grid_image.shape[dim], grid_spacing[dim]):
slicer = [slice(None)] * grid_image.ndim
slicer[dim] = slice(offset, offset + 1)
grid_image[slicer] = True
# saving resulting grid volume
save(grid_image, args.output, grid_header, args.force)
def main():
parser = getParser()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# loading input images
img, hdr = load(args.input)
img = img.astype(numpy.bool)
# check spacing values
if not len(args.spacing) == img.ndim:
parser.error('The image has {} dimensions, but {} spacing parameters have been supplied.'.format(img.ndim, len(args.spacing)))
# check if output image exists
if not args.force:
if os.path.exists(args.output):
parser.error('The output image {} already exists.'.format(args.output))
logger.debug('target voxel spacing: {}'.format(args.spacing))
# determine number of required complete slices for up-sampling
vs = header.get_pixel_spacing(hdr)
rcss = [int(y // x - 1) for x, y in zip(args.spacing, vs)] # TODO: For option b, remove the - 1; better: no option b, since I am rounding later anyway
# remove negatives and round up to next even number
rcss = [x if x > 0 else 0 for x in rcss]
rcss = [x if 0 == x % 2 else x + 1 for x in rcss]
logger.debug('intermediate slices to add per dimension: {}'.format(rcss))
# for each dimension requiring up-sampling, from the highest down, perform shape based slice interpolation
logger.info('Adding required slices using shape based interpolation.')
for dim, rcs in enumerate(rcss):
if rcs > 0:
logger.debug('adding {} intermediate slices to dimension {}'.format(rcs, dim))
img = shape_based_slice_interpolation(img, dim, rcs)
logger.debug('resulting new image shape: {}'.format(img.shape))
# compute and set new voxel spacing
nvs = [x / (y + 1.) for x, y in zip(vs, rcss)]
header.set_pixel_spacing(hdr, nvs)
logger.debug('intermediate voxel spacing: {}'.format(nvs))
# interpolate with nearest neighbour
logger.info('Re-sampling the image with a b-spline order of {}.'.format(args.order))
img, hdr = resample(img, hdr, args.spacing, args.order, mode='nearest')
# saving the resulting image
save(img, args.output, hdr, args.force)
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# copy the example image or generate empty image, depending on the modus
if args.example:
grid_image = scipy.zeros(args.example_image.shape, scipy.bool_)
grid_header = args.example_header
else:
grid_image = scipy.zeros(args.shape, scipy.bool_)
# !TODO: Find another solution for this
# Saving and loading image once to generate a valid header
tmp_dir = tempfile.mkdtemp()
tmp_image = '{}/{}'.format(tmp_dir, args.output.split('/')[-1])
save(grid_image, tmp_image)
_, grid_header = load(tmp_image)
try:
os.remove(tmp_image)
os.rmdir(tmp_dir)
except Exception:
pass
# set the image attributes if supplied
if args.pixelspacing:
header.set_pixel_spacing(grid_header, args.pixelspacing)
if args.offset:
header.set_offset(grid_header, args.offset)
# compute the right grid spacing for each dimension
if args.real:
grid_spacing = [int(round(sp / float(ps))) for sp, ps in zip(args.spacing, header.get_pixel_spacing(grid_header))]
else:
grid_spacing = args.spacing
# paint the grid into the empty image volume
for dim in range(grid_image.ndim):
if 0 == grid_spacing[dim]: continue # skip dimension of 0 grid spacing supplied
for offset in range(0, grid_image.shape[dim], grid_spacing[dim]):
slicer = [slice(None)] * grid_image.ndim
slicer[dim] = slice(offset, offset + 1)
grid_image[slicer] = True
# saving resulting grid volume
save(grid_image, args.output, grid_header, args.force)
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input
data_input, header_input = load(args.image)
# change pixel spacing
logger.info('Setting pixel spacing along {} to {}...'.format(data_input.shape, args.spacing))
header.set_pixel_spacing(header_input, args.spacing)
# save file
save(data_input.copy(), args.image, header_input, True)
logger.info("Successfully terminated.")
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input
data_input, header_input = load(args.input)
# change pixel spacing
logger.info('Setting pixel spacing along {} to {}...'.format(data_input.shape, args.spacing))
header.set_pixel_spacing(header_input, args.spacing)
# save file
save(data_input, args.output, header_input, args.force)
logger.info("Successfully terminated.")
def main():
parser = getParser()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# loading input images
img, hdr = load(args.input)
# check spacing values
if not len(args.spacing) == img.ndim:
parser.error(
'The image has {} dimensions, but {} spacing parameters have been supplied.'
.format(img.ndim, len(args.spacing)))
# check if output image exists
if not args.force:
if os.path.exists(args.output):
parser.error('The output image {} already exists.'.format(
args.output))
logger.debug('target voxel spacing: {}'.format(args.spacing))
# compute zoom values
zoom_factors = [
old / float(new)
for new, old in zip(args.spacing, header.get_pixel_spacing(hdr))
]
logger.debug('zoom-factors: {}'.format(zoom_factors))
# zoom image
img = scipy.ndimage.interpolation.zoom(img, zoom_factors, order=args.order)
logger.debug('new image shape: {}'.format(img.shape))
# set new voxel spacing
header.set_pixel_spacing(hdr, args.spacing)
# saving the resulting image
save(img, args.output, hdr, args.force)
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input image
data_input, header_input = load(args.input)
logger.debug('Original shape = {}.'.format(data_input.shape))
# check if supplied dimension parameters is inside the images dimensions
if args.dimension1 >= data_input.ndim or args.dimension1 < 0:
raise ArgumentError(
'The first swap-dimension {} exceeds the number of input volume dimensions {}.'
.format(args.dimension1, data_input.ndim))
elif args.dimension2 >= data_input.ndim or args.dimension2 < 0:
raise ArgumentError(
'The second swap-dimension {} exceeds the number of input volume dimensions {}.'
.format(args.dimension2, data_input.ndim))
# swap axes
data_output = scipy.swapaxes(data_input, args.dimension1, args.dimension2)
# swap pixel spacing and offset
ps = list(header.get_pixel_spacing(header_input))
ps[args.dimension1], ps[args.dimension2] = ps[args.dimension2], ps[
args.dimension1]
header.set_pixel_spacing(header_input, ps)
os = list(header.get_offset(header_input))
os[args.dimension1], os[args.dimension2] = os[args.dimension2], os[
args.dimension1]
header.set_offset(header_input, os)
logger.debug('Resulting shape = {}.'.format(data_output.shape))
# save resulting volume
save(data_output, args.output, header_input, args.force)
logger.info("Successfully terminated.")
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input image
data_input, header_input = load(args.input)
# check if the supplied dimension is valid
if args.dimension >= data_input.ndim or args.dimension < 0:
raise ArgumentError(
'The supplied cut-dimension {} exceeds the image dimensionality of 0 to {}.'
.format(args.dimension, data_input.ndim - 1))
# prepare output file string
name_output = args.output.replace('{}', '{:03d}')
# compute the new the voxel spacing
spacing = list(header.get_pixel_spacing(header_input))
del spacing[args.dimension]
# iterate over the cut dimension
slices = data_input.ndim * [slice(None)]
for idx in range(data_input.shape[args.dimension]):
# cut the current slice from the original image
slices[args.dimension] = slice(idx, idx + 1)
data_output = scipy.squeeze(data_input[slices])
# update the header and set the voxel spacing
__update_header_from_array_nibabel(header_input, data_output)
header.set_pixel_spacing(header_input, spacing)
# save current slice
save(data_output, name_output.format(idx), header_input, args.force)
logger.info("Successfully terminated.")
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# constants
contour_dimension = 2
# load input data
input_data, input_header = load(args.input)
# create output array
new_shape = list(input_data.shape)
new_shape[contour_dimension] = input_data.shape[contour_dimension] + (input_data.shape[contour_dimension] - 1) * args.enhancement
output_data = scipy.zeros(new_shape, scipy.uint8)
# prepare slicers
slicer_from = [slice(None)] * input_data.ndim
slicer_to = [slice(None)] * output_data.ndim
logger.debug('Old shape = {}.'.format(input_data.shape))
# copy data
for idx in range(input_data.shape[contour_dimension]):
slicer_from[contour_dimension] = slice(idx, idx + 1)
slicer_to[contour_dimension] = slice(idx * (args.enhancement + 1), idx * (args.enhancement + 1) + 1)
output_data[slicer_to] = input_data[slicer_from]
logger.debug('New shape = {}.'.format(output_data.shape))
new_spacing = list(header.get_pixel_spacing(input_header))
new_spacing[contour_dimension] = new_spacing[contour_dimension] / float(args.enhancement + 1)
logger.debug('Setting pixel spacing from {} to {}....'.format(header.get_pixel_spacing(input_header), new_spacing))
header.set_pixel_spacing(input_header, tuple(new_spacing))
save(output_data, args.output, input_header, args.force)
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load input image
data_input, header_input = load(args.input)
# check if the supplied dimension is valid
if args.dimension >= data_input.ndim or args.dimension < 0:
raise ArgumentError('The supplied cut-dimension {} exceeds the image dimensionality of 0 to {}.'.format(args.dimension, data_input.ndim - 1))
# prepare output file string
name_output = args.output.replace('{}', '{:03d}')
# compute the new the voxel spacing
spacing = list(header.get_pixel_spacing(header_input))
del spacing[args.dimension]
# iterate over the cut dimension
slices = data_input.ndim * [slice(None)]
for idx in range(data_input.shape[args.dimension]):
# cut the current slice from the original image
slices[args.dimension] = slice(idx, idx + 1)
data_output = scipy.squeeze(data_input[slices])
# update the header and set the voxel spacing
__update_header_from_array_nibabel(header_input, data_output)
header.set_pixel_spacing(header_input, spacing)
# save current slice
save(data_output, name_output.format(idx), header_input, args.force)
logger.info("Successfully terminated.")
def zoom(image, factor, dimension, hdr=False, order=3):
"""
Zooms the provided image by the supplied factor in the supplied dimension.
The factor is an integer determining how many slices should be put between each
existing pair.
If an image header (hdr) is supplied, its voxel spacing gets updated.
Returns the image and the updated header or false.
"""
# check if supplied dimension is valid
if dimension >= image.ndim:
raise argparse.ArgumentError(
'The supplied zoom-dimension {} exceeds the image dimensionality of 0 to {}.'
.format(dimension, image.ndim - 1))
# get logger
logger = Logger.getInstance()
logger.debug('Old shape = {}.'.format(image.shape))
# perform the zoom
zoom = [1] * image.ndim
zoom[dimension] = (image.shape[dimension] +
(image.shape[dimension] - 1) * factor) / float(
image.shape[dimension])
logger.debug('Reshaping with = {}.'.format(zoom))
image = interpolation.zoom(image, zoom, order=order)
logger.debug('New shape = {}.'.format(image.shape))
if hdr:
new_spacing = list(header.get_pixel_spacing(hdr))
new_spacing[dimension] = new_spacing[dimension] / float(factor + 1)
logger.debug('Setting pixel spacing from {} to {}....'.format(
header.get_pixel_spacing(hdr), new_spacing))
header.set_pixel_spacing(hdr, tuple(new_spacing))
return image, hdr
def main():
parser = getParser()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# loading input images
img, hdr = load(args.input)
# check spacing values
if not len(args.spacing) == img.ndim:
parser.error('The image has {} dimensions, but {} spacing parameters have been supplied.'.format(img.ndim, len(args.spacing)))
# check if output image exists
if not args.force:
if os.path.exists(args.output):
parser.error('The output image {} already exists.'.format(args.output))
logger.debug('target voxel spacing: {}'.format(args.spacing))
# compute zoom values
zoom_factors = [old / float(new) for new, old in zip(args.spacing, header.get_pixel_spacing(hdr))]
logger.debug('zoom-factors: {}'.format(zoom_factors))
# zoom image
img = scipy.ndimage.interpolation.zoom(img, zoom_factors, order=args.order)
logger.debug('new image shape: {}'.format(img.shape))
# set new voxel spacing
header.set_pixel_spacing(hdr, args.spacing)
# saving the resulting image
save(img, args.output, hdr, args.force)
def test_MetadataConsistency(self):
"""
This test checks the ability of different image formats to consistently save
meta-data information. Especially if a conversion between formats is required,
that involves different 3rd party modules, this is not always guaranteed.
The images are saved in one format, loaded and then saved in another format.
Subsequently the differences in the meta-data is checked.
Currently this test can only check:
- voxel spacing
- image offset
Note that some other test are inherently performed by the
loadsave.TestIOFacilities class:
- data type
- shape
- content
With the verboose switches, a comprehensive list of the results can be obtianed.
"""
####
# VERBOOSE SETTINGS
# The following are two variables that can be used to print some nicely
# formatted additional output. When one of them is set to True, this unittest
# should be run stand-alone.
####
# Print a list of format to format conversion which preserve meta-data
consistent = True
# Print a list of format to format conversion which do not preserve meta-data
inconsistent = True
# Print a list of formats that failed conversion in general
unsupported = False
####
# OTHER SETTINGS
####
# debug settings
logger = Logger.getInstance()
#logger.setLevel(logging.DEBUG)
# run test either for most important formats or for all (see loadsave.TestIOFacilities)
#__suffixes = self.__important # (choice 1)
__suffixes = self.__pydicom + self.__nifti + self.__itk + self.__itk_more # (choice 2)
# dimensions and dtypes to check
__suffixes = list(set(__suffixes))
__ndims = [1, 2, 3, 4, 5]
__dtypes = [scipy.bool_,
scipy.int8, scipy.int16, scipy.int32, scipy.int64,
scipy.uint8, scipy.uint16, scipy.uint32, scipy.uint64,
scipy.float32, scipy.float64, #scipy.float128, # last one removed, as not present on every machine
scipy.complex64, scipy.complex128, ] #scipy.complex256 ## removed, as not present on every machine
# prepare struct to save settings that passed the test
consistent_types = dict.fromkeys(__suffixes)
for k0 in consistent_types:
consistent_types[k0] = dict.fromkeys(__suffixes)
for k1 in consistent_types[k0]:
consistent_types[k0][k1] = dict.fromkeys(__ndims)
for k2 in consistent_types[k0][k1]:
consistent_types[k0][k1][k2] = []
# prepare struct to save settings that did not
inconsistent_types = dict.fromkeys(__suffixes)
for k0 in inconsistent_types:
inconsistent_types[k0] = dict.fromkeys(__suffixes)
for k1 in inconsistent_types[k0]:
inconsistent_types[k0][k1] = dict.fromkeys(__ndims)
for k2 in inconsistent_types[k0][k1]:
inconsistent_types[k0][k1][k2] = dict.fromkeys(__dtypes)
# prepare struct to save settings that did not pass the data integrity test
unsupported_types = dict.fromkeys(__suffixes)
for k0 in consistent_types:
unsupported_types[k0] = dict.fromkeys(__suffixes)
for k1 in unsupported_types[k0]:
unsupported_types[k0][k1] = dict.fromkeys(__ndims)
for k2 in unsupported_types[k0][k1]:
unsupported_types[k0][k1][k2] = dict.fromkeys(__dtypes)
# create artifical images, save them, load them again and compare them
path = tempfile.mkdtemp()
try:
for ndim in __ndims:
logger.debug('Testing for dimension {}...'.format(ndim))
arr_base = scipy.random.randint(0, 10, range(10, ndim + 10))
for dtype in __dtypes:
arr_save = arr_base.astype(dtype)
for suffix_from in __suffixes:
# do not run test, if in avoid array
if ndim in self.__avoid and suffix_from in self.__avoid[ndim]:
unsupported_types[suffix_from][suffix_from][ndim][dtype] = "Test skipped, as combination in the tests __avoid array."
continue
# save array as file, load again to obtain header and set the meta-data
image_from = '{}/img{}'.format(path, suffix_from)
try:
save(arr_save, image_from, None, True)
if not os.path.exists(image_from):
raise Exception('Image of type {} with shape={}/dtype={} has been saved without exception, but the file does not exist.'.format(suffix_from, arr_save.shape, dtype))
except Exception as e:
unsupported_types[suffix_from][suffix_from][ndim][dtype] = e.message
continue
try:
img_from, hdr_from = load(image_from)
img_from = img_from.astype(dtype) # change dtype of loaded image again, as sometimes the type is higher (e.g. int64 instead of int32) after loading!
except Exception as e:
unsupported_types[suffix_from][suffix_from][ndim][dtype] = 'Saved reference image of type {} with shape={}/dtype={} could not be loaded. Reason: {}'.format(suffix_from, arr_save.shape, dtype, e.message)
continue
header.set_pixel_spacing(hdr_from, [scipy.random.rand() * scipy.random.randint(1, 10) for _ in range(img_from.ndim)])
try:
header.set_pixel_spacing(hdr_from, [scipy.random.rand() * scipy.random.randint(1, 10) for _ in range(img_from.ndim)])
header.set_offset(hdr_from, [scipy.random.rand() * scipy.random.randint(1, 10) for _ in range(img_from.ndim)])
except Exception as e:
logger.error('Could not set the header meta-data for image of type {} with shape={}/dtype={}. This should not happen and hints to a bug in the code. Signaled reason is: {}'.format(suffix_from, arr_save.shape, dtype, e))
unsupported_types[suffix_from][suffix_from][ndim][dtype] = e.message
continue
for suffix_to in __suffixes:
# do not run test, if in avoid array
if ndim in self.__avoid and suffix_to in self.__avoid[ndim]:
unsupported_types[suffix_from][suffix_to][ndim][dtype] = "Test skipped, as combination in the tests __avoid array."
continue
# for each other format, try format to format conversion an check if the meta-data is consistent
image_to = '{}/img_to{}'.format(path, suffix_to)
try:
save(img_from, image_to, hdr_from, True)
if not os.path.exists(image_to):
raise Exception('Image of type {} with shape={}/dtype={} has been saved without exception, but the file does not exist.'.format(suffix_to, arr_save.shape, dtype))
except Exception as e:
unsupported_types[suffix_from][suffix_from][ndim][dtype] = e.message
continue
try:
_, hdr_to = load(image_to)
except Exception as e:
unsupported_types[suffix_from][suffix_to][ndim][dtype] = 'Saved testing image of type {} with shape={}/dtype={} could not be loaded. Reason: {}'.format(suffix_to, arr_save.shape, dtype, e.message)
continue
msg = self.__diff(hdr_from, hdr_to)
if msg:
inconsistent_types[suffix_from][suffix_to][ndim][dtype] = msg
else:
consistent_types[suffix_from][suffix_to][ndim].append(dtype)
# remove testing image
if os.path.exists(image_to): os.remove(image_to)
# remove reference image
if os.path.exists(image_to): os.remove(image_to)
except Exception:
if not os.listdir(path): os.rmdir(path)
else: logger.debug('Could not delete temporary directory {}. Is not empty.'.format(path))
raise
if consistent:
print '\nthe following format conversions are meta-data consistent:'
print 'from\tto\tndim\tdtypes'
for suffix_from in consistent_types:
for suffix_to in consistent_types[suffix_from]:
for ndim, dtypes in consistent_types[suffix_from][suffix_to].iteritems():
if list == type(dtypes) and not 0 == len(dtypes):
print '{}\t{}\t{}D\t{}'.format(suffix_from, suffix_to, ndim, map(lambda x: str(x).split('.')[-1][:-2], dtypes))
if inconsistent:
print '\nthe following form conversions are not meta-data consistent:'
print 'from\tto\tndim\tdtype\t\terror'
for suffix_from in inconsistent_types:
for suffix_to in inconsistent_types[suffix_from]:
for ndim in inconsistent_types[suffix_from][suffix_to]:
for dtype, msg in inconsistent_types[suffix_from][suffix_to][ndim].iteritems():
if msg:
print '{}\t{}\t{}D\t{}\t\t{}'.format(suffix_from, suffix_to, ndim, str(dtype).split('.')[-1][:-2], msg)
if unsupported:
print '\nthe following form conversions could not be tested due to errors:'
print 'from\tto\tndim\tdtype\t\terror'
for suffix_from in unsupported_types:
for suffix_to in unsupported_types[suffix_from]:
for ndim in unsupported_types[suffix_from][suffix_to]:
for dtype, msg in unsupported_types[suffix_from][suffix_to][ndim].iteritems():
if msg:
print '{}\t{}\t{}D\t{}\t\t{}'.format(suffix_from, suffix_to, ndim, str(dtype).split('.')[-1][:-2], msg)
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# constants
dimension_spatial = 0
dimension_temporal = 3
name_output_data = '{}/{}_d{:01d}_s{:04d}.nii' # basename / slice-dimension / slice-number
name_output_marker = '{}/m{}_d{:01d}_s{:04d}.nii' # basename / slice-dimension / slice-number
# load input image
input_data, input_header = load(args.input)
# determine type of extraction and eventuelly load contour file
if args.paintc or args.type in ['es']:
contour_data, _ = load(args.contour)
# select dimension and set variable parameter
if args.type in ['ed', 'es', 'spatial']: cut_dimension = dimension_temporal
else: cut_dimension = dimension_spatial
basename = '.'.join(os.path.basename(args.input).split('.')[:-1])
# adjust voxel spacing
voxel_spacing = list(header.get_pixel_spacing(input_header))
del voxel_spacing[cut_dimension]
voxel_spacing += [0]
header.set_pixel_spacing(input_header, voxel_spacing)
# split and save images
first = True
slices = input_data.ndim * [slice(None)]
for idx in range(input_data.shape[cut_dimension]):
slices[cut_dimension] = slice(idx, idx + 1)
# skip if output image already exists
if not args.force and os.path.exists(name_output_data.format(args.output, basename, cut_dimension, idx)):
logger.warning('The output image {} already exists, skipping this step.'.format(name_output_data.format(args.output, basename, cut_dimension, idx)))
continue
elif not args.force and os.path.exists(name_output_marker.format(args.output, basename, cut_dimension, idx)):
logger.warning('The output marker image {} already exists, skipping this step.'.format(name_output_marker.format(args.output, basename, cut_dimension, idx)))
continue
# extract original sub-volume
data_output = scipy.squeeze(input_data[slices])
# create same-sized empty volume as marker base
data_marker = scipy.zeros(data_output.shape, scipy.uint8)
# extract also contour sub-volume if required
if args.paintc:
data_marker += scipy.squeeze(contour_data[slices])
# check if contour data is empty in ed and es case; if yes, skip this volume
if args.type in ['es'] and 0 == len(scipy.squeeze(contour_data[slices]).nonzero()[0]):
continue
# check if first volume in case of type = es, then skip
if 'es' == args.type and first:
first = False
continue
# save data and marker sub-volumes
save(data_output, name_output_data.format(args.output, basename, cut_dimension, idx), input_header, args.force)
save(data_marker, name_output_marker.format(args.output, basename, cut_dimension, idx), input_header, args.force)
# in case of type = ed, break after first
if 'ed' == args.type: break
logger.info("Successfully terminated.")
def main():
args = getArguments(getParser())
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# constants
dimension_spatial = 0
dimension_temporal = 3
name_output_data = '{}/{}_d{:01d}_s{:04d}.nii' # basename / slice-dimension / slice-number
name_output_marker = '{}/m{}_d{:01d}_s{:04d}.nii' # basename / slice-dimension / slice-number
# load input image
input_data, input_header = load(args.input)
# determine type of extraction and eventuelly load contour file
if args.paintc or args.type in ['es']:
contour_data, _ = load(args.contour)
# select dimension and set variable parameter
if args.type in ['ed', 'es', 'spatial']: cut_dimension = dimension_temporal
else: cut_dimension = dimension_spatial
basename = '.'.join(os.path.basename(args.input).split('.')[:-1])
# adjust voxel spacing
voxel_spacing = list(header.get_pixel_spacing(input_header))
del voxel_spacing[cut_dimension]
voxel_spacing += [0]
header.set_pixel_spacing(input_header, voxel_spacing)
# split and save images
first = True
slices = input_data.ndim * [slice(None)]
for idx in range(input_data.shape[cut_dimension]):
slices[cut_dimension] = slice(idx, idx + 1)
# skip if output image already exists
if not args.force and os.path.exists(name_output_data.format(args.output, basename, cut_dimension, idx)):
logger.warning('The output image {} already exists, skipping this step.'.format(name_output_data.format(args.output, basename, cut_dimension, idx)))
continue
elif not args.force and os.path.exists(name_output_marker.format(args.output, basename, cut_dimension, idx)):
logger.warning('The output marker image {} already exists, skipping this step.'.format(name_output_marker.format(args.output, basename, cut_dimension, idx)))
continue
# extract original sub-volume
data_output = scipy.squeeze(input_data[slices])
# create same-sized empty volume as marker base
data_marker = scipy.zeros(data_output.shape, scipy.uint8)
# extract also contour sub-volume if required
if args.paintc:
data_marker += scipy.squeeze(contour_data[slices])
# check if contour data is empty in ed and es case; if yes, skip this volume
if args.type in ['es'] and 0 == len(scipy.squeeze(contour_data[slices]).nonzero()[0]):
continue
# check if first volume in case of type = es, then skip
if 'es' == args.type and first:
first = False
continue
# save data and marker sub-volumes
save(data_output, name_output_data.format(args.output, basename, cut_dimension, idx), input_header, args.force)
save(data_marker, name_output_marker.format(args.output, basename, cut_dimension, idx), input_header, args.force)
# in case of type = ed, break after first
if 'ed' == args.type: break
logger.info("Successfully terminated.")
def test_MetadataConsistency(self):
"""
This test checks the ability of different image formats to consistently save
meta-data information. Especially if a conversion between formats is required,
that involves different 3rd party modules, this is not always guaranteed.
The images are saved in one format, loaded and then saved in another format.
Subsequently the differences in the meta-data is checked.
Currently this test can only check:
- voxel spacing
- image offset
Note that some other test are inherently performed by the
loadsave.TestIOFacilities class:
- data type
- shape
- content
With the verboose switches, a comprehensive list of the results can be obtianed.
"""
####
# VERBOOSE SETTINGS
# The following are two variables that can be used to print some nicely
# formatted additional output. When one of them is set to True, this unittest
# should be run stand-alone.
####
# Print a list of format to format conversion which preserve meta-data
consistent = True
# Print a list of format to format conversion which do not preserve meta-data
inconsistent = False
# Print a list of formats that failed conversion in general
unsupported = False
####
# OTHER SETTINGS
####
# debug settings
logger = Logger.getInstance()
#logger.setLevel(logging.DEBUG)
# run test either for most important formats or for all (see loadsave.TestIOFacilities)
#__suffixes = self.__important # (choice 1)
__suffixes = self.__important + self.__itk # (choice 2)
# dimensions and dtypes to check
__suffixes = list(set(__suffixes))
__ndims = [1, 2, 3, 4, 5]
__dtypes = [
scipy.bool_,
scipy.int8,
scipy.int16,
scipy.int32,
scipy.int64,
scipy.uint8,
scipy.uint16,
scipy.uint32,
scipy.uint64,
scipy.float32,
scipy.
float64, #scipy.float128, # last one removed, as not present on every machine
scipy.complex64,
scipy.complex128,
] #scipy.complex256 ## removed, as not present on every machine
# prepare struct to save settings that passed the test
consistent_types = dict.fromkeys(__suffixes)
for k0 in consistent_types:
consistent_types[k0] = dict.fromkeys(__suffixes)
for k1 in consistent_types[k0]:
consistent_types[k0][k1] = dict.fromkeys(__ndims)
for k2 in consistent_types[k0][k1]:
consistent_types[k0][k1][k2] = []
# prepare struct to save settings that did not
inconsistent_types = dict.fromkeys(__suffixes)
for k0 in inconsistent_types:
inconsistent_types[k0] = dict.fromkeys(__suffixes)
for k1 in inconsistent_types[k0]:
inconsistent_types[k0][k1] = dict.fromkeys(__ndims)
for k2 in inconsistent_types[k0][k1]:
inconsistent_types[k0][k1][k2] = dict.fromkeys(__dtypes)
# prepare struct to save settings that did not pass the data integrity test
unsupported_types = dict.fromkeys(__suffixes)
for k0 in consistent_types:
unsupported_types[k0] = dict.fromkeys(__suffixes)
for k1 in unsupported_types[k0]:
unsupported_types[k0][k1] = dict.fromkeys(__ndims)
for k2 in unsupported_types[k0][k1]:
unsupported_types[k0][k1][k2] = dict.fromkeys(__dtypes)
# create artifical images, save them, load them again and compare them
path = tempfile.mkdtemp()
try:
for ndim in __ndims:
logger.debug('Testing for dimension {}...'.format(ndim))
arr_base = scipy.random.randint(0, 10,
list(range(10, ndim + 10)))
for dtype in __dtypes:
arr_save = arr_base.astype(dtype)
for suffix_from in __suffixes:
# do not run test, if in avoid array
if ndim in self.__avoid and suffix_from in self.__avoid[
ndim]:
unsupported_types[suffix_from][suffix_from][ndim][
dtype] = "Test skipped, as combination in the tests __avoid array."
continue
# save array as file, load again to obtain header and set the meta-data
image_from = '{}/img{}'.format(path, suffix_from)
try:
save(arr_save, image_from, None, True)
if not os.path.exists(image_from):
raise Exception(
'Image of type {} with shape={}/dtype={} has been saved without exception, but the file does not exist.'
.format(suffix_from, arr_save.shape,
dtype))
except Exception as e:
unsupported_types[suffix_from][suffix_from][
ndim][dtype] = e.message if hasattr(
e, 'message') else str(e.args)
continue
try:
img_from, hdr_from = load(image_from)
img_from = img_from.astype(
dtype
) # change dtype of loaded image again, as sometimes the type is higher (e.g. int64 instead of int32) after loading!
except Exception as e:
_message = e.message if hasattr(
e, 'message') else str(e.args)
unsupported_types[suffix_from][suffix_from][ndim][
dtype] = 'Saved reference image of type {} with shape={}/dtype={} could not be loaded. Reason: {}'.format(
suffix_from, arr_save.shape, dtype,
_message)
continue
header.set_pixel_spacing(hdr_from, [
scipy.random.rand() * scipy.random.randint(1, 10)
for _ in range(img_from.ndim)
])
try:
header.set_pixel_spacing(hdr_from, [
scipy.random.rand() *
scipy.random.randint(1, 10)
for _ in range(img_from.ndim)
])
header.set_offset(hdr_from, [
scipy.random.rand() *
scipy.random.randint(1, 10)
for _ in range(img_from.ndim)
])
except Exception as e:
logger.error(
'Could not set the header meta-data for image of type {} with shape={}/dtype={}. This should not happen and hints to a bug in the code. Signaled reason is: {}'
.format(suffix_from, arr_save.shape, dtype, e))
unsupported_types[suffix_from][suffix_from][
ndim][dtype] = e.message if hasattr(
e, 'message') else str(e.args)
continue
for suffix_to in __suffixes:
# do not run test, if in avoid array
if ndim in self.__avoid and suffix_to in self.__avoid[
ndim]:
unsupported_types[suffix_from][suffix_to][ndim][
dtype] = "Test skipped, as combination in the tests __avoid array."
continue
# for each other format, try format to format conversion an check if the meta-data is consistent
image_to = '{}/img_to{}'.format(path, suffix_to)
try:
save(img_from, image_to, hdr_from, True)
if not os.path.exists(image_to):
raise Exception(
'Image of type {} with shape={}/dtype={} has been saved without exception, but the file does not exist.'
.format(suffix_to, arr_save.shape,
dtype))
except Exception as e:
unsupported_types[suffix_from][suffix_from][
ndim][dtype] = e.message if hasattr(
e, 'message') else str(e.args)
continue
try:
_, hdr_to = load(image_to)
except Exception as e:
_message = e.message if hasattr(
e, 'message') else str(e.args)
unsupported_types[suffix_from][suffix_to][ndim][
dtype] = 'Saved testing image of type {} with shape={}/dtype={} could not be loaded. Reason: {}'.format(
suffix_to, arr_save.shape, dtype,
_message)
continue
msg = self.__diff(hdr_from, hdr_to)
if msg:
inconsistent_types[suffix_from][suffix_to][
ndim][dtype] = msg
else:
consistent_types[suffix_from][suffix_to][
ndim].append(dtype)
# remove testing image
if os.path.exists(image_to): os.remove(image_to)
# remove reference image
if os.path.exists(image_to): os.remove(image_to)
except Exception:
if not os.listdir(path): os.rmdir(path)
else:
logger.debug(
'Could not delete temporary directory {}. Is not empty.'.
format(path))
raise
if consistent:
print(
'\nthe following format conversions are meta-data consistent:')
print('from\tto\tndim\tdtypes')
for suffix_from in consistent_types:
for suffix_to in consistent_types[suffix_from]:
for ndim, dtypes in list(
consistent_types[suffix_from][suffix_to].items()):
if list == type(dtypes) and not 0 == len(dtypes):
print(('{}\t{}\t{}D\t{}'.format(
suffix_from, suffix_to, ndim,
[str(x).split('.')[-1][:-2] for x in dtypes])))
if inconsistent:
print(
'\nthe following form conversions are not meta-data consistent:'
)
print('from\tto\tndim\tdtype\t\terror')
for suffix_from in inconsistent_types:
for suffix_to in inconsistent_types[suffix_from]:
for ndim in inconsistent_types[suffix_from][suffix_to]:
for dtype, msg in list(inconsistent_types[suffix_from]
[suffix_to][ndim].items()):
if msg:
print(('{}\t{}\t{}D\t{}\t\t{}'.format(
suffix_from, suffix_to, ndim,
str(dtype).split('.')[-1][:-2], msg)))
if unsupported:
print(
'\nthe following form conversions could not be tested due to errors:'
)
print('from\tto\tndim\tdtype\t\terror')
for suffix_from in unsupported_types:
for suffix_to in unsupported_types[suffix_from]:
for ndim in unsupported_types[suffix_from][suffix_to]:
for dtype, msg in list(unsupported_types[suffix_from]
[suffix_to][ndim].items()):
if msg:
print(('{}\t{}\t{}D\t{}\t\t{}'.format(
suffix_from, suffix_to, ndim,
str(dtype).split('.')[-1][:-2], msg)))
def main():
# parse cmd arguments
parser = getParser()
parser.parse_args()
args = getArguments(parser)
# prepare logger
logger = Logger.getInstance()
if args.debug: logger.setLevel(logging.DEBUG)
elif args.verbose: logger.setLevel(logging.INFO)
# load first input image as example
example_data, example_header = load(args.inputs[0])
# test if the supplied position is valid
if args.position > example_data.ndim or args.position < 0:
raise ArgumentError(
'The supplied position for the new dimension is invalid. It has to be between 0 and {}.'
.format(example_data.ndim))
# prepare empty output volume
output_data = scipy.zeros([len(args.inputs)] + list(example_data.shape),
dtype=example_data.dtype)
# add first image to output volume
output_data[0] = example_data
# load input images and add to output volume
for idx, image in enumerate(args.inputs[1:]):
image_data, _ = load(image)
if not args.ignore and image_data.dtype != example_data.dtype:
raise ArgumentError(
'The dtype {} of image {} differs from the one of the first image {}, which is {}.'
.format(image_data.dtype, image, args.inputs[0],
example_data.dtype))
if image_data.shape != example_data.shape:
raise ArgumentError(
'The shape {} of image {} differs from the one of the first image {}, which is {}.'
.format(image_data.shape, image, args.inputs[0],
example_data.shape))
output_data[idx + 1] = image_data
# move new dimension to the end or to target position
for dim in range(output_data.ndim - 1):
if dim >= args.position: break
output_data = scipy.swapaxes(output_data, dim, dim + 1)
# set pixel spacing
spacing = list(header.get_pixel_spacing(example_header))
spacing = tuple(spacing[:args.position] + [args.spacing] +
spacing[args.position:])
# !TODO: Find a way to enable this also for PyDicom and ITK images
if __is_header_nibabel(example_header):
__update_header_from_array_nibabel(example_header, output_data)
header.set_pixel_spacing(example_header, spacing)
else:
raise ArgumentError(
"Sorry. Setting the voxel spacing of the new dimension only works with NIfTI images. See the description of this program for more details."
)
# save created volume
save(output_data, args.output, example_header, args.force)
logger.info("Successfully terminated.")