def write_itk(image_np, output_file, affine, dtype, compress):
if len(image_np.shape) > 2:
image_np = image_np.transpose().copy()
if dtype:
image_np = image_np.astype(dtype)
result_image = itk.image_from_array(image_np)
logger.debug(f"ITK Image size: {itk.size(result_image)}")
# https://github.com/RSIP-Vision/medio/blob/master/medio/metadata/affine.py#L108-L121
if affine is not None:
convert_aff_mat = np.diag([-1, -1, 1, 1])
if affine.shape[0] == 3:
convert_aff_mat = np.diag([-1, -1, 1])
affine = convert_aff_mat @ affine
dim = affine.shape[0] - 1
_origin_key = (slice(-1), -1)
_m_key = (slice(-1), slice(-1))
origin = affine[_origin_key]
spacing = np.linalg.norm(affine[_m_key] @ np.eye(dim), axis=0)
direction = affine[_m_key] @ np.diag(1 / spacing)
logger.debug(f"Affine: {affine}")
logger.debug(f"Origin: {origin}")
logger.debug(f"Spacing: {spacing}")
logger.debug(f"Direction: {direction}")
result_image.SetDirection(itk.matrix_from_array(direction))
result_image.SetSpacing(spacing)
result_image.SetOrigin(origin)
itk.imwrite(result_image, output_file, compress)
def to_itk_image(image_like):
if isinstance(image_like, itk.Image):
return image_like
if is_arraylike(image_like):
array = np.asarray(image_like)
can_use_view = array.flags['OWNDATA']
if have_dask and isinstance(image_like, dask.array.core.Array):
can_use_view = False
array = np.ascontiguousarray(array)
# JavaScript does not support 64-bit integers
if array.dtype == np.int64:
array = array.astype(np.float32)
elif array.dtype == np.uint64:
array = array.astype(np.float32)
if can_use_view:
image_from_array = itk.image_view_from_array(array)
else:
image_from_array = itk.image_from_array(array)
return image_from_array
elif have_vtk and isinstance(image_like, vtk.vtkImageData):
from vtk.util import numpy_support as vtk_numpy_support
array = vtk_numpy_support.vtk_to_numpy(
image_like.GetPointData().GetScalars())
array.shape = tuple(image_like.GetDimensions())[::-1]
image_from_array = itk.image_view_from_array(array)
image_from_array.SetSpacing(image_like.GetSpacing())
image_from_array.SetOrigin(image_like.GetOrigin())
return image_from_array
elif have_simpleitk and isinstance(image_like, sitk.Image):
array = sitk.GetArrayViewFromImage(image_like)
image_from_array = itk.image_view_from_array(array)
image_from_array.SetSpacing(image_like.GetSpacing())
image_from_array.SetOrigin(image_like.GetOrigin())
direction = image_like.GetDirection()
npdirection = np.asarray(direction)
npdirection = np.reshape(npdirection, (-1, 3))
itkdirection = itk.matrix_from_array(npdirection)
image_from_array.SetDirection(itkdirection)
return image_from_array
elif have_imagej:
import imglyb
if isinstance(image_like,
imglyb.util.ReferenceGuardingRandomAccessibleInterval):
array = imglyb.to_numpy(image_like)
image_from_array = itk.image_view_from_array(array)
return image_from_array
elif isinstance(image_like, itk.ProcessObject):
return itk.output(image_like)
return None
def resampling_transform(image, shape):
imageType = itk.template(image)[0][itk.template(image)[1]]
dummy_image = itk.image_from_array(np.zeros(tuple(reversed(shape)), dtype=itk.array_from_image(image).dtype))
if len(shape) == 2:
transformType = itk.MatrixOffsetTransformBase[itk.D, 2, 2]
else:
transformType = itk.VersorRigid3DTransform[itk.D]
initType = itk.CenteredTransformInitializer[transformType, imageType, imageType]
initializer = initType.New()
initializer.SetFixedImage(dummy_image)
initializer.SetMovingImage(image)
transform = transformType.New()
initializer.SetTransform(transform)
initializer.InitializeTransform()
if len(shape) == 3:
transformType = itk.MatrixOffsetTransformBase[itk.D, 3, 3]
t2 = transformType.New()
t2.SetCenter(transform.GetCenter())
t2.SetOffset(transform.GetOffset())
transform = t2
m = transform.GetMatrix()
m_a = itk.array_from_matrix(m)
input_shape = image.GetLargestPossibleRegion().GetSize()
for i in range(len(shape)):
m_a[i, i] = image.GetSpacing()[i] * (input_shape[i] / shape[i])
m_a = itk.array_from_matrix(image.GetDirection()) @ m_a
transform.SetMatrix(itk.matrix_from_array(m_a))
return transform
def spine_slice(image, params):
"""
image is the ITK image to slice from
params is a SliceParams object"""
output_spacing = [params.height / params.px, params.width / params.px, 1]
output_origin = [
val + params.direction[j, 0] * -params.height / 2 +
params.direction[j, 1] * -params.width / 2
for j, val in enumerate(params.origin)
]
#print(output_origin)
#print(output_spacing)
return itk.resample_image_filter(image,
output_origin=output_origin,
output_spacing=output_spacing,
OutputDirection=itk.matrix_from_array(
np.ascontiguousarray(
params.direction)),
size=[params.px, params.px, 1])
assert m1.get(0, 0) != m_np[0, 0] view = itk.GetArrayViewFromVnlMatrix(m1) assert m1.get(0, 0) == view[0, 0] view[0, 0] = 0 assert m1.get(0, 0) == view[0, 0] arr = np.zeros([3, 3]) m_vnl = itk.GetVnlMatrixFromArray(arr) assert m_vnl(0, 0) == 0 m_vnl.put(0, 0, 3) assert m_vnl(0, 0) == 3 assert arr[0, 0] == 0 # ITK Matrix arr = np.zeros([3, 3], float) m_itk = itk.GetMatrixFromArray(arr) # Test snake case function m_itk = itk.matrix_from_array(arr) m_itk.SetIdentity() # Test that the numpy array has not changed,... assert arr[0, 0] == 0 # but that the ITK matrix has the correct value. assert m_itk(0, 0) == 1 arr2 = itk.GetArrayFromMatrix(m_itk) # Check that snake case function also works arr2 = itk.array_from_matrix(m_itk) # Check that the new array has the new value. assert arr2[0, 0] == 1 arr2[0, 0] = 2 # Change the array value,... assert arr2[0, 0] == 2 # and make sure that the matrix hasn't changed. assert m_itk(0, 0) == 1
assert m1.get(0,0) != m_np[0,0] view = itk.GetArrayViewFromVnlMatrix(m1) assert m1.get(0,0) == view[0,0] view[0,0] = 0 assert m1.get(0,0) == view[0,0] arr = np.zeros([3,3]) m_vnl = itk.GetVnlMatrixFromArray(arr) assert m_vnl(0,0) == 0 m_vnl.put(0,0,3) assert m_vnl(0,0) == 3 assert arr[0,0] == 0 # ITK Matrix arr = np.zeros([3,3],float) m_itk = itk.GetMatrixFromArray(arr) # Test snake case function m_itk = itk.matrix_from_array(arr) m_itk.SetIdentity() # Test that the numpy array has not changed,... assert arr[0,0] == 0 # but that the ITK matrix has the correct value. assert m_itk(0,0) == 1 arr2 = itk.GetArrayFromMatrix(m_itk) # Check that snake case function also works arr2 = itk.array_from_matrix(m_itk) # Check that the new array has the new value. assert arr2[0,0] == 1 arr2[0,0]=2 # Change the array value,... assert arr2[0,0] == 2 # and make sure that the matrix hasn't changed. assert m_itk(0,0) == 1
assert m1.get(0, 0) != m_np[0, 0] view = itk.GetArrayViewFromVnlMatrix(m1) assert m1.get(0, 0) == view[0, 0] view[0, 0] = 0 assert m1.get(0, 0) == view[0, 0] arr = np.zeros([3, 3]) m_vnl = itk.GetVnlMatrixFromArray(arr) assert m_vnl(0, 0) == 0 m_vnl.put(0, 0, 3) assert m_vnl(0, 0) == 3 assert arr[0, 0] == 0 # ITK Matrix arr = np.zeros([3, 3], float) m_itk = itk.GetMatrixFromArray(arr) # Test snake case function m_itk = itk.matrix_from_array(arr) m_itk.SetIdentity() # Test that the numpy array has not changed,... assert arr[0, 0] == 0 # but that the ITK matrix has the correct value. assert m_itk(0, 0) == 1 arr2 = itk.GetArrayFromMatrix(m_itk) # Check that snake case function also works arr2 = itk.array_from_matrix(m_itk) # Check that the new array has the new value. assert arr2[0, 0] == 1 arr2[0, 0] = 2 # Change the array value,... assert arr2[0, 0] == 2 # and make sure that the matrix hasn't changed. assert m_itk(0, 0) == 1
def reorient(img, new_orientation=ITK_COORDINATE_ORIENTATION_LPI, new_dir = standard_dir):
# this function is implemented using ITK since SimpleITK has not implemented the filter "OrientImageFilter" yet
# the ITK orientation system is from this blog post: https://itk.org/pipermail/insight-users/2017-May/054606.html
# comparison ITK - simpleITK filters: https://itk.org/SimpleITKDoxygen/html/Filter_Coverage.html
# see also: https://github.com/fedorov/lidc-idri-conversion/blob/master/seg/seg_converter.py
# change image name
img_sitk = img
# get characteristics of simpleITK image
size_in_sitk = img_sitk.GetSize()
spacing_in_sitk = img_sitk.GetSpacing()
origin_in_sitk = img_sitk.GetOrigin()
direction_in_sitk = img_sitk.GetDirection()
# allocate ITK image (type and size)
Dimension = 3
PixelType = itk.F
ImageTypeIn = itk.Image[PixelType, Dimension]
img_itk = ImageTypeIn.New()
sizeIn_itk = itk.Size[Dimension]()
for i in range (0,Dimension):
sizeIn_itk[i] = size_in_sitk[i]
region = itk.ImageRegion[Dimension]()
region.SetSize(sizeIn_itk)
img_itk.SetRegions(region)
img_itk.Allocate()
# pass image from simpleITK to numpy
img_py = sitk.GetArrayFromImage(img_sitk)
# pass image from numpy to ITK
img_itk = itk.GetImageViewFromArray(img_py)
# pass characteristics from simpleITK image to ITK image (except size, assigned in allocation)
spacing_in_itk = itk.Vector[itk.F, Dimension]()
for i in range (0,Dimension):
spacing_in_itk[i] = spacing_in_sitk[i]
img_itk.SetSpacing(spacing_in_itk)
origin_in_itk = itk.Point[itk.F, Dimension]()
for i in range (0,Dimension):
origin_in_itk[i] = origin_in_sitk[i]
img_itk.SetOrigin(origin_in_itk)
# old way of assigning direction (until ITK 4.13)
# direction_in_itk = itk.Matrix[itk.F,3,3]()
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(0,0,direction_in_sitk[0]) # r,c,value
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(0,1,direction_in_sitk[1])
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(0,2,direction_in_sitk[2])
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(1,0,direction_in_sitk[3]) # r,c,value
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(1,1,direction_in_sitk[4])
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(1,2,direction_in_sitk[5])
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(2,0,direction_in_sitk[6]) # r,c,value
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(2,1,direction_in_sitk[7])
# direction_in_itk = img_itk.GetDirection().GetVnlMatrix().set(2,2,direction_in_sitk[8])
direction_in_itk = np.eye(3)
direction_in_itk[0][0] = direction_in_sitk[0]
direction_in_itk[0][1] = direction_in_sitk[1]
direction_in_itk[0][2] = direction_in_sitk[2]
direction_in_itk[1][0] = direction_in_sitk[3]
direction_in_itk[1][1] = direction_in_sitk[4]
direction_in_itk[1][2] = direction_in_sitk[5]
direction_in_itk[2][0] = direction_in_sitk[6]
direction_in_itk[2][1] = direction_in_sitk[7]
direction_in_itk[2][2] = direction_in_sitk[8]
img_itk.SetDirection(itk.matrix_from_array(direction_in_itk))
# make sure image is float for the orientation filter (GetImageViewFromArray sets it to unsigned char)
ImageTypeIn_afterPy = type(img_itk)
ImageTypeOut = itk.Image[itk.F, 3]
CastFilterType = itk.CastImageFilter[ImageTypeIn_afterPy, ImageTypeOut]
castFilter = CastFilterType.New()
castFilter.SetInput(img_itk)
castFilter.Update()
img_itk = castFilter.GetOutput()
# change orientation to RAI
OrientType = itk.OrientImageFilter[ImageTypeOut,ImageTypeOut]
filter = OrientType.New()
filter.UseImageDirectionOn()
filter.SetDesiredCoordinateOrientation(new_orientation)
filter.SetInput(img_itk)
filter.Update()
img_itk = filter.GetOutput()
# get characteristics of ITK image
spacing_out_itk = img_itk.GetSpacing()
origin_out_itk = img_itk.GetOrigin()
# pass image from itk to numpy
img_py = itk.GetArrayViewFromImage(img_itk)
# pass image from numpy to simpleitk
img = sitk.GetImageFromArray(img_py)
# pass characteristics from ITK image to simpleITK image (except size, implicitely passed)
spacing = []
for i in range (0, Dimension):
spacing.append(spacing_out_itk[i])
img.SetSpacing(spacing)
origin = []
for i in range (0, Dimension):
origin.append(origin_out_itk[i])
img.SetOrigin(origin)
img.SetDirection(new_dir)
return img
def to_itk_image(image_like):
if isinstance(image_like, (itk.Image, itk.VectorImage)):
return image_like
if is_arraylike(image_like):
array = np.asarray(image_like)
can_use_view = array.flags['OWNDATA']
if have_dask and isinstance(image_like, dask.array.core.Array):
can_use_view = False
array = np.ascontiguousarray(array)
# JavaScript does not support 64-bit integers
if array.dtype == np.int64:
array = array.astype(np.float32)
elif array.dtype == np.uint64:
array = array.astype(np.float32)
if can_use_view:
image_from_array = itk.image_view_from_array(array)
else:
image_from_array = itk.image_from_array(array)
return image_from_array
elif have_vtk and isinstance(image_like, vtk.vtkImageData):
from vtk.util import numpy_support as vtk_numpy_support
array = vtk_numpy_support.vtk_to_numpy(
image_like.GetPointData().GetScalars())
dims = list(image_like.GetDimensions())
spacing = list(image_like.GetSpacing())
origin = list(image_like.GetOrigin())
# Check for zdim==1
zdim = dims.pop()
if zdim > 1:
# zdim>1, put it back in the dims array
dims.append(zdim)
else:
#zdim==1, remove z-spacing and z-origin
spacing.pop()
origin.pop()
array.shape = dims[::-1]
image_from_array = itk.image_view_from_array(array)
image_from_array.SetSpacing(spacing)
image_from_array.SetOrigin(origin)
return image_from_array
elif have_simpleitk and isinstance(image_like, sitk.Image):
array = sitk.GetArrayViewFromImage(image_like)
image_from_array = itk.image_view_from_array(array)
image_from_array.SetSpacing(image_like.GetSpacing())
image_from_array.SetOrigin(image_like.GetOrigin())
direction = image_like.GetDirection()
npdirection = np.asarray(direction)
npdirection = np.reshape(npdirection, (-1, image_like.GetDimension()))
itkdirection = itk.matrix_from_array(npdirection)
image_from_array.SetDirection(itkdirection)
return image_from_array
elif have_imagej:
import imglyb
if isinstance(image_like,
imglyb.util.ReferenceGuardingRandomAccessibleInterval):
array = imglyb.to_numpy(image_like)
image_from_array = itk.image_view_from_array(array)
return image_from_array
elif isinstance(image_like, itk.ProcessObject):
return itk.output(image_like)
return None
def applyTransformation(input=None,
like=None,
spacinglike=None,
matrix=None,
newsize=None,
neworigin=None,
newspacing=None,
newdirection=None,
force_resample=None,
keep_original_canvas=None,
adaptive=None,
rotation=None,
rotation_center=None,
translation=None,
pad=None,
interpolation_mode=None,
bspline_order=2):
if like is not None and spacinglike is not None:
logger.error("Choose between like and spacinglike options")
sys.exit(1)
if newspacing is not None and spacinglike is not None:
logger.error("Choose between newspacing and spacinglike options")
sys.exit(1)
if force_resample is None:
force_resample = False
if keep_original_canvas is None:
keep_original_canvas = False
if force_resample and keep_original_canvas:
logger.error(
"Choose between force_resample and keep_original_canvas options")
sys.exit(1)
if adaptive is None:
adaptive = False
if adaptive and not force_resample:
logger.error(
"Be sure to activate force_resample flag with adaptive flag")
sys.exit(1)
if force_resample and adaptive and (newspacing is not None or spacinglike
is not None) and newsize is not None:
logger.error(
"With adaptive flag, choose between spacing and size options")
sys.exit(1)
imageDimension = input.GetImageDimension()
if newsize is None:
newsize = input.GetLargestPossibleRegion().GetSize()
if len(newsize) != imageDimension:
logger.error("Size of newsize is not correct (" + str(imageDimension) +
"): " + str(newsize))
sys.exit(1)
if newspacing is None:
newspacing = input.GetSpacing()
if len(newspacing) != imageDimension:
logger.error("Size of newspacing is not correct (" +
str(imageDimension) + "): " + str(newspacing))
sys.exit(1)
if newdirection is None:
newdirection = input.GetDirection()
if newdirection.GetVnlMatrix().columns(
) != imageDimension or newdirection.GetVnlMatrix().rows(
) != imageDimension:
logger.error("Size of newdirection is not correct (" +
str(imageDimension) + "): " + str(newdirection))
sys.exit(1)
if like is not None:
if like.GetImageDimension() != imageDimension:
logger.error(
"Like image does not have the same dimension than input")
sys.exit(1)
newsize = like.GetLargestPossibleRegion().GetSize()
neworigin = like.GetOrigin()
newspacing = like.GetSpacing()
newdirection = like.GetDirection()
if spacinglike is not None:
if spacinglike.GetImageDimension() != imageDimension:
logger.error(
"Spacinglike image does not have the same dimension than input"
)
sys.exit(1)
newspacing = spacinglike.GetSpacing()
if pad is None:
pad = 0.0
if interpolation_mode is None:
interpolation_mode: "linear"
if not force_resample and not keep_original_canvas:
if neworigin is None:
neworigin = input.GetOrigin()
changeInfoFilter = itk.ChangeInformationImageFilter.New(Input=input)
changeInfoFilter.SetOutputSpacing(newspacing)
changeInfoFilter.SetOutputOrigin(neworigin)
changeInfoFilter.SetOutputDirection(newdirection)
changeInfoFilter.ChangeSpacingOn()
changeInfoFilter.ChangeOriginOn()
changeInfoFilter.ChangeDirectionOn()
changeInfoFilter.Update()
return changeInfoFilter.GetOutput()
centerImageIndex = itk.ContinuousIndex[itk.D, imageDimension]()
for i in range(imageDimension):
centerImageIndex[i] = (input.GetLargestPossibleRegion().GetSize()[i] -
1) / 2.0
centerImagePoint = input.TransformContinuousIndexToPhysicalPoint(
centerImageIndex)
centerImageArray = [0] * imageDimension
for i in range(imageDimension):
centerImageArray[i] = centerImagePoint[i]
if rotation_center is None:
rotation_center = np.zeros(imageDimension)
for i in range(imageDimension):
rotation_center[i] = centerImagePoint[i]
if len(rotation_center) != imageDimension:
logger.error("Size of rotation_center is not correct (" +
str(imageDimension) + "): " + str(rotation_center))
sys.exit(1)
rotationMatrix = []
translationMatrix = []
if not matrix is None:
if not rotation is None or not translation is None:
logger.error(
"Choose between matrix or rotation/translation, not both")
sys.exit(1)
if matrix.GetVnlMatrix().columns(
) != imageDimension + 1 or matrix.GetVnlMatrix().rows(
) != imageDimension + 1:
logger.error("Size of matrix transformation is not correct (" +
str(imageDimension + 1) + "): " + str(matrix))
sys.exit(1)
if matrix.GetVnlMatrix().columns() == 3 or matrix.GetVnlMatrix(
).columns() == 4:
rotationMatrix = itk.matrix_from_array(
itk.array_from_matrix(matrix)
[:imageDimension, :imageDimension])
else:
logger.error("We can transform only 2D and 3D images")
sys.exit(1)
else:
if imageDimension == 2:
if rotation is None:
rotation = [0]
if len(rotation) != 1:
logger.error("Size of rotation is not correct (1): " +
str(rotation))
sys.exit(1)
elif imageDimension == 3:
if rotation is None:
rotation = [0] * imageDimension
if len(rotation) != imageDimension:
logger.error("Size of rotation is not correct (3): " +
str(rotation))
sys.exit(1)
if translation is None:
translation = [0] * imageDimension
if len(translation) != imageDimension:
logger.error("Size of translation is not correct (" +
str(imageDimension) + "): " + str(translation))
sys.exit(1)
if imageDimension == 2:
euler = itk.Euler2DTransform[itk.D].New()
euler.SetRotation(rotation[0] * math.pi / 180.0)
rotationMatrix = euler.GetMatrix()
elif imageDimension == 3:
euler = itk.Euler3DTransform[itk.D].New()
euler.SetRotation(rotation[0] * math.pi / 180.0,
rotation[1] * math.pi / 180.0,
rotation[2] * math.pi / 180.0)
rotationMatrix = euler.GetMatrix()
else:
logger.error("We can transform only 2D and 3D images")
sys.exit(1)
transform = itk.AffineTransform[itk.D, imageDimension].New()
transform.SetCenter([0] * imageDimension)
transform.SetTranslation([0] * imageDimension)
transform.SetMatrix(rotationMatrix)
inverseTransform = itk.AffineTransform[itk.D, imageDimension].New()
transform.GetInverse(inverseTransform)
if not matrix is None:
translation = itk.array_from_matrix(
matrix
)[:imageDimension,
imageDimension] - rotation_center + rotationMatrix * rotation_center
translationMatrix = inverseTransform.GetMatrix() * (
centerImageArray - rotation_center) - (
centerImageArray -
rotation_center) - inverseTransform.GetMatrix() * translation
inputOrigin = itk.Point[itk.D, imageDimension]()
for i in range(imageDimension):
inputOrigin[i] = input.GetOrigin()[i]
preTranslateFilter = itk.ChangeInformationImageFilter.New(Input=input)
preTranslateFilter.CenterImageOn()
preTranslateFilter.Update()
cornersIndex = [
itk.ContinuousIndex[itk.D, imageDimension]()
for i in range(2**imageDimension)
]
if imageDimension == 2 or imageDimension == 3:
cornersIndex[0][0] = -0.5
cornersIndex[0][1] = -0.5
if imageDimension == 3:
cornersIndex[0][2] = -0.5
cornersIndex[1][0] = input.GetLargestPossibleRegion().GetSize(
)[0] - 0.5
cornersIndex[1][1] = cornersIndex[0][1]
if imageDimension == 3:
cornersIndex[1][2] = cornersIndex[0][2]
cornersIndex[2][0] = cornersIndex[0][0]
cornersIndex[2][1] = input.GetLargestPossibleRegion().GetSize(
)[1] - 0.5
if imageDimension == 3:
cornersIndex[2][2] = cornersIndex[0][2]
cornersIndex[3][0] = cornersIndex[1][0]
cornersIndex[3][1] = cornersIndex[2][1]
if imageDimension == 3:
cornersIndex[3][2] = cornersIndex[0][2]
if imageDimension == 3:
cornersIndex[4][0] = cornersIndex[0][0]
cornersIndex[4][1] = cornersIndex[0][1]
cornersIndex[4][2] = input.GetLargestPossibleRegion().GetSize(
)[2] - 0.5
cornersIndex[5][0] = cornersIndex[1][0]
cornersIndex[5][1] = cornersIndex[0][1]
cornersIndex[5][2] = cornersIndex[4][2]
cornersIndex[6][0] = cornersIndex[0][0]
cornersIndex[6][1] = cornersIndex[2][1]
cornersIndex[6][2] = cornersIndex[4][2]
cornersIndex[7][0] = cornersIndex[1][0]
cornersIndex[7][1] = cornersIndex[2][1]
cornersIndex[7][2] = cornersIndex[4][2]
outputCorners = np.zeros((2**imageDimension, imageDimension))
for i in range(2**imageDimension):
outputCorners[i, :] = inverseTransform.GetMatrix(
) * preTranslateFilter.GetOutput(
).TransformContinuousIndexToPhysicalPoint(cornersIndex[i])
minOutputCorner = np.zeros(imageDimension)
maxOutputCorner = np.zeros(imageDimension)
for i in range(imageDimension):
minOutputCorner[i] = min(outputCorners[:, i])
maxOutputCorner[i] = max(outputCorners[:, i])
temp = minOutputCorner + 0.5 * itk.array_from_vnl_vector(
newspacing.GetVnlVector())
originAfterRotation = itk.Point[itk.D, imageDimension]()
for i in range(imageDimension):
originAfterRotation[i] = temp[i]
temp = (maxOutputCorner - minOutputCorner) / itk.array_from_vnl_vector(
newspacing.GetVnlVector())
sizeAfterRotation = itk.Size[imageDimension]()
for i in range(imageDimension):
sizeAfterRotation[i] = int(math.ceil(temp[i]))
else:
logger.error("We can transform only 2D and 3D images")
sys.exit(1)
tempImageType = itk.Image[itk.F, imageDimension]
castImageFilter = itk.CastImageFilter[type(input), tempImageType].New()
castImageFilter.SetInput(preTranslateFilter.GetOutput())
castImageFilter.Update()
resampleFilter = itk.ResampleImageFilter.New(
Input=castImageFilter.GetOutput())
resampleFilter.SetOutputSpacing(newspacing)
resampleFilter.SetOutputOrigin(originAfterRotation)
resampleDirection = itk.matrix_from_array(np.eye(imageDimension))
resampleFilter.SetOutputDirection(resampleDirection)
resampleFilter.SetSize(sizeAfterRotation)
resampleFilter.SetTransform(transform)
if interpolation_mode == "NN":
interpolator = itk.NearestNeighborInterpolateImageFunction[
tempImageType, itk.D].New()
elif interpolation_mode == "BSpline":
interpolator = itk.BSplineInterpolateImageFunction[tempImageType,
itk.D, itk.F].New()
interpolator.SetSplineOrder(bspline_order)
else:
interpolator = itk.LinearInterpolateImageFunction[tempImageType,
itk.D].New()
resampleFilter.SetInterpolator(interpolator)
resampleFilter.SetDefaultPixelValue(pad)
resampleFilter.Update()
postTranslateFilter = itk.ChangeInformationImageFilter.New(
Input=resampleFilter.GetOutput())
postTranslateFilter.SetOutputOrigin(originAfterRotation +
centerImagePoint + translationMatrix)
postTranslateFilter.ChangeOriginOn()
postTranslateFilter.Update()
if neworigin is None and not (itk.array_from_matrix(input.GetDirection())
== np.eye(imageDimension)).all():
neworigin = postTranslateFilter.GetOutput().GetOrigin()
elif neworigin is None:
neworigin = inputOrigin
if len(neworigin) != imageDimension:
logger.error("Size of neworigin is not correct (" +
str(imageDimension) + "): " + str(neworigin))
sys.exit(1)
if force_resample and adaptive:
if (np.array(newspacing) == np.array(input.GetSpacing())).all():
temp = np.array(sizeAfterRotation) * itk.array_from_vnl_vector(
newspacing.GetVnlVector()) / np.array(newsize)
newspacing = itk.Vector[itk.D, imageDimension]()
for i in range(imageDimension):
newspacing[i] = temp[i]
else:
newsize = itk.Size[imageDimension]()
for i in range(imageDimension):
newsize[i] = sizeAfterRotation[i]
identityTransform = itk.AffineTransform[itk.D, imageDimension].New()
resampleFilterCanvas = itk.ResampleImageFilter.New(
Input=postTranslateFilter.GetOutput())
resampleFilterCanvas.SetOutputSpacing(newspacing)
resampleFilterCanvas.SetOutputOrigin(neworigin)
resampleFilterCanvas.SetOutputDirection(resampleDirection)
resampleFilterCanvas.SetSize(newsize)
resampleFilterCanvas.SetTransform(identityTransform)
if interpolation_mode == "NN":
interpolator = itk.NearestNeighborInterpolateImageFunction[
tempImageType, itk.D].New()
else:
interpolator = itk.LinearInterpolateImageFunction[tempImageType,
itk.D].New()
resampleFilterCanvas.SetInterpolator(interpolator)
resampleFilterCanvas.SetDefaultPixelValue(pad)
resampleFilterCanvas.Update()
castImageFilter2 = itk.CastImageFilter[tempImageType, type(input)].New()
castImageFilter2.SetInput(resampleFilterCanvas.GetOutput())
castImageFilter2.Update()
return castImageFilter2.GetOutput()
# Do NumPy stuff... # Convert back to ITK, view only, data is not copied itk_np_view = itk.image_view_from_array(np_copy) # Convert back to ITK, data is copied itk_np_copy = itk.image_from_array(np_copy) # Save result itk.imwrite(itk_np_view, output_filename) # VNL matrix from array arr = np.zeros([3, 3], np.uint8) matrix = itk.vnl_matrix_from_array(arr) # Array from VNL matrix arr = itk.array_from_vnl_matrix(matrix) # VNL vector from array vec = np.zeros([3], np.uint8) vnl_vector = itk.vnl_vector_from_array(vec) # Array from VNL vector vec = itk.array_from_vnl_vector(vnl_vector) # itk.Matrix from array mat = itk.matrix_from_array(np.eye(3)) # array from itk.Matrix arr = itk.array_from_matrix(mat)
def reorientation(input_image):
region3d = input_image.GetBufferedRegion()
start3d = region3d.GetIndex()
# region3d = mask3d.GetBufferedRegion()
# start3d = region3d.GetIndex()
# size3d = region3d.GetSize()
spacing3d = input_image.GetSpacing()
#new_direction_list = [1., 0., 0., 0., 1., 0., 0., 0., 1.]
new_direction_list = [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]
new_direction = itk.matrix_from_array(np.array(new_direction_list))
#print(new_direction)
# def is_equal(old, new, EPS=1e-6):
# for a, b in zip(old, new):
# if np.abs(a-b) > EPS:
# return False
# return True
# if np.array_equal(old_direction, new_direction):
# meta = {}
# meta['origin'] = input_image.GetOrigin()
# meta['direction'] = old_direction
# return input_image, meta
I, J, K = input_image.GetBufferedRegion().GetSize()
coords = []
for i in [0, I - 1]:
for j in [0, J - 1]:
for k in [0, K - 1]:
coords.append([i, j, k])
coords = [input_image.TransformIndexToPhysicalPoint(t) for t in coords]
coords = np.array(coords)
min_i, max_i = np.min(coords[:, 0]), np.max(coords[:, 0])
min_j, max_j = np.min(coords[:, 1]), np.max(coords[:, 1])
min_k, max_k = np.min(coords[:, 2]), np.max(coords[:, 2])
new_origin = [min_i, min_j, min_k]
new_size = [0, 0, 0]
new_size[0] = int(round((max_i - min_i) / spacing3d[0])) + 1
new_size[1] = int(round((max_j - min_j) / spacing3d[1])) + 1
new_size[2] = int(round((max_k - min_k) / spacing3d[2])) + 1
# resampleFilter = sitk.ResampleImageFilter()
# resampleFilter.SetOutputSpacing(spacing3d)
# resampleFilter.SetOutputOrigin(new_origin)
# resampleFilter.SetOutputDirection(new_direction) ####
# resampleFilter.SetInterpolator(sitk.sitkNearestNeighbor)
# resampleFilter.SetSize(new_size)
# output_image = resampleFilter.Execute(input_image)
# resample
interpolatorType = itk.LinearInterpolateImageFunction[ImageType, itk.D]
interpolator = interpolatorType.New()
resample2dFilter = itk.ResampleImageFilter[ImageType, ImageType].New()
resample2dFilter.SetInterpolator(interpolator)
resample2dFilter.SetSize(new_size)
resample2dFilter.SetOutputOrigin(new_origin)
resample2dFilter.SetOutputDirection(new_direction)
resample2dFilter.SetOutputSpacing(spacing3d)
resample2dFilter.SetOutputStartIndex(start3d)
resample2dFilter.SetInput(input_image)
resample2dFilter.Update()
output_image = resample2dFilter.GetOutput()
meta = {}
meta['origin'] = new_origin
meta['direction'] = new_direction
return output_image
