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
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