Medical Imaging Interaction Toolkit
2024.06.00
Medical Imaging Interaction Toolkit
|
This subcategory includes adaptor classes for the integration of algorithms from other toolkits, especially ITK. More...
Classes | |
class | mitk::AccessByItkException |
Exception class thrown in AccessByItk macros. More... | |
class | mitk::ImageToItk< TOutputImage > |
class | mitk::ITKImageImport< TInputImage > |
Pipelined import of itk::Image. More... | |
Macros | |
#define | AccessByItk(mitkImage, itkImageTypeFunction) |
Access a MITK image by an ITK image. More... | |
#define | AccessFixedPixelTypeByItk(mitkImage, itkImageTypeFunction, pixelTypeSeq) |
Access a mitk-image with known pixeltype (but unknown dimension) by an itk-image. More... | |
#define | AccessFixedDimensionByItk(mitkImage, itkImageTypeFunction, dimension) |
Access a mitk-image with known dimension by an itk-image. More... | |
#define | AccessFixedTypeByItk(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq) |
Access a mitk-image with known type (pixel type and dimension) by an itk-image. More... | |
#define | AccessByItk_n(mitkImage, itkImageTypeFunction, va_tuple) |
Access a MITK image by an ITK image with one or more parameters. More... | |
#define | AccessFixedPixelTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, va_tuple) |
Access a mitk-image with known pixeltype (but unknown dimension) by an itk-image with one or more parameters. More... | |
#define | AccessFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, va_tuple) |
Access a mitk-image with known dimension by an itk-image with one or more parameters. More... | |
#define | AccessVectorFixedDimensionByItk_n(mitkImage, itkImageTypeFunction, dimension, va_tuple) |
Access a vector mitk-image with known dimension by a ITK vector image with one or more parameters. More... | |
#define | AccessFixedTypeByItk_n(mitkImage, itkImageTypeFunction, pixelTypeSeq, dimSeq, va_tuple) |
Access a mitk-image with known type (pixel type and dimension) by an itk-image with one or more parameters. More... | |
#define | AccessTwoImagesFixedDimensionByItk(mitkImage1, mitkImage2, itkImageTypeFunction, dimension) |
Access two mitk-images with known dimension by itk-images. More... | |
#define | InstantiateAccessFunctionForFixedType(itkImgFunc, pixelTypeSeq, dimSeq) |
Instantiate access function for the given pixel types and dimensions. More... | |
#define | InstantiateAccessFunction(itkImgFunc) |
Instantiate access function for all datatypes and dimensions. More... | |
#define | InstantiateAccessFunctionForFixedDimension(itkImgFunc, dim) |
Instantiate access function for all datatypes and a specific dimension. More... | |
#define | InstantiateAccessFunctionForFixedPixelType(itkImgFunc, pixelTypeSeq) |
Instantiate access function for all given pixel types and all dimensions. More... | |
#define | InstantiateAccessFunctionForIntegralPixelTypes(itkImgFunc) |
Instantiate access function for integral datatypes and all dimensions. More... | |
#define | InstantiateAccessFunctionForFloatingPixelTypes(itkImgFunc) |
Instantiate access function for floating point datatypes and all dimensions. More... | |
Functions | |
template<typename ItkOutputImageType > | |
void MITKCORE_EXPORT | mitk::CastToItkImage (const mitk::Image *mitkImage, itk::SmartPointer< ItkOutputImageType > &itkOutputImage) |
Cast an mitk::Image to an itk::Image with a specific type. More... | |
template<typename TPixelType , unsigned int VImageDimension> | |
void MITKCORE_EXPORT | mitk::CastToItkImage (const mitk::Image *mitkImage, itk::SmartPointer< itk::VectorImage< TPixelType, VImageDimension >> &itkOutputImage) |
Cast an mitk::Image to an itk::VectorImage with a specific type. More... | |
template<typename ItkOutputImageType > | |
void | mitk::CastToMitkImage (const itk::SmartPointer< ItkOutputImageType > &itkimage, itk::SmartPointer< mitk::Image > &mitkoutputimage) |
Cast an itk::Image (with a specific type) to an mitk::Image. More... | |
template<typename ItkOutputImageType > | |
void | mitk::CastToMitkImage (const ItkOutputImageType *itkimage, itk::SmartPointer< mitk::Image > &mitkoutputimage) |
Cast an itk::Image (with a specific type) to an mitk::Image. More... | |
template<typename TPixel , unsigned int VDimension> | |
ImageTypeTrait< TPixel, VDimension >::ImageType::Pointer | mitk::ImageToItkImage (mitk::Image *mitkImage) |
Convert a MITK image to an ITK image. More... | |
template<typename TPixel , unsigned int VDimension> | |
ImageTypeTrait< TPixel, VDimension >::ImageType::ConstPointer | mitk::ImageToItkImage (const mitk::Image *mitkImage) |
Convert a MITK image to an ITK image. More... | |
template<typename ItkOutputImageType > | |
Image::Pointer | mitk::ImportItkImage (const itk::SmartPointer< ItkOutputImageType > &itkimage, const BaseGeometry *geometry=nullptr, bool update=true) |
Imports an itk::Image (with a specific type) as an mitk::Image. More... | |
template<typename ItkOutputImageType > | |
Image::Pointer | mitk::ImportItkImage (const ItkOutputImageType *itkimage, const BaseGeometry *geometry=nullptr, bool update=true) |
Imports an itk::Image (with a specific type) as an mitk::Image. More... | |
template<typename ItkOutputImageType > | |
Image::Pointer | mitk::GrabItkImageMemory (itk::SmartPointer< ItkOutputImageType > &itkimage, mitk::Image *mitkImage=nullptr, const BaseGeometry *geometry=nullptr, bool update=true) |
Grabs the memory of an itk::Image (with a specific type) and puts it into an mitk::Image. More... | |
template<typename ItkOutputImageType > | |
Image::Pointer | mitk::GrabItkImageMemory (ItkOutputImageType *itkimage, mitk::Image *mitkImage=nullptr, const BaseGeometry *geometry=nullptr, bool update=true) |
Grabs the memory of an itk::Image (with a specific type) and puts it into an mitk::Image. More... | |
template<typename ItkOutputImageType > | |
Image::Pointer | mitk::GrabItkImageMemoryChannel (ItkOutputImageType *itkimage, const TimeGeometry *geometry=nullptr, mitk::Image *mitkImage=nullptr, bool update=true) |
Grabs the memory of an itk::Image (with a specific type) and puts it into an mitk::Image. More... | |
This subcategory includes adaptor classes for the integration of algorithms from other toolkits, especially ITK.
The task of most of the classes in this category is to deal with the conversion between the (templated) itk::Image and the (not-templated) mitk::Image. Methods for conversion are provided for both directions:
Care has to be taken regarding the involved coordinate systems, see ITK image vs MITK coordinate systems.
For limitations on ITK-type conversion see the section Limitations.
VTK-based access to MITK images is straightforward: simply ask your mitk::Image for a vtkImageData by calling Image:GetVtkImageData. Similarly, to get a vtkPolyData from the MITK class for storing surfaces, mitk::Surface, call Surface::GetVtkPolyData.
Pixel type and dimension of MITK images can be specified at run time whereas ITK images are templated over the pixel type and the dimension, thus in ITK both need to be specified at compile time.
There two different situations, which are covered in the following sub-sections:
If you know the type (pixel type and dimension) of the MITK image you have two options:
Thus, mitk::CastToItkImage is the more powerful variant: here it is sufficient that you know what you want to have (the ITK data type), to which the MITK image will be casted, if needed.
If you do not know the pixel type/dimension of an MITK image in advance and the ITK image should have the same (unknown) type, e.g., to run a filter on the MITK image data, we cannot really convert to one ITK image. This is simply, because we cannot instantiate an itk::Image object with unknown pixel type/dimension.
Nevertheless, MITK provides a way to access an MITK image as if it was an ITK image of unknown type. To do so, first define an access method, which is templated as an ITK image is:
If you don't understand this template syntax, we need to refer you to an C++ text book. Understanding template syntax is crucial to successfully using ITK.
To call this templated method with an (untemplated) mitk::Image, you can use the AccessByItk macro (or one of its variants) from mitkImageAccessByItk.h. This macro checks for the actual image type of the mitk::Image and does any necessary conversions. This works for all configured pixel types (default is char, unsigned char, short, unsigned short, int, unsigned int, float, and double) and dimensions (default is 2 and 3). You can change the considered default pixel types and dimensions by modifying the CMake variables MITK_ACCESSBYITK_*.
An example is given in MITK Tutorial - Step 6: Use an interactive region-grower.
The AccessBy... macros create quite a lot of code: the user defined access method has to be compiled for all considered pixel types times the supported dimensions (default is 2 and 3). Therefore, depending on the complexity of the access method, some compilers may run into problems with memory. One workaround is to use explicit instantiation and distribute it on multiple files. The macro InstantiateAccessFunction and its variants are for this purpose. An example is again given in MITK Tutorial - Step 6: Use an interactive region-grower. Another workaround is to reduce the created code by fixing either the type (AccessFixedTypeByItk) or dimension (AccessFixedDimensionByItk).
There is one variant of AccessByItk... for passing additional parameters to the access-function, called AccessFixedTypeByItk_n.
Converting ITK images to MITK is easier than the other way round. Basically, you have three options:
Converting coordinates from the ITK physical coordinate system (which does not support rotated images) to the MITK world coordinate system should be performed via the Geometry3D of the Image, see mitk::Geometry3D::WorldToItkPhysicalPoint.
The MITK to ITK adaptors for unspecified types have to do type multiplexing at compile time. This is done for a limited number of pixel types and dimensions, defined during the CMake configuration process.
Especially, color image types are not multiplexed. This is because many algorithms do not support color images (e.g. with data type itk::RGBPixel) because they do not have a scalar data type. If your algorithm do support color and you want to multiplex over all scalar as well as the color data type, try the following:
#define AccessByItk | ( | mitkImage, | |
itkImageTypeFunction | |||
) |
Access a MITK image by an ITK image.
Define a templated function or method (itkImageTypeFunction) within which the mitk-image (mitkImage) is accessed:
The itk::Image passed to the function/method has the same data-pointer as the mitk-image. Depending on the const-ness of the mitkImage
, your templated access function needs to take a const or non-const itk::Image pointer and you will get read-only or full read/write access to the data vector of the mitk-image using the itk-image.
Example code using the access function above:
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
Definition at line 188 of file mitkImageAccessByItk.h.
#define AccessByItk_n | ( | mitkImage, | |
itkImageTypeFunction, | |||
va_tuple | |||
) |
Access a MITK image by an ITK image with one or more parameters.
Define a templated function or method (itkImageTypeFunction) with one or more additional parameters, within which the mitk-image (mitkImage) is accessed:
The itk::Image passed to the function/method has the same data-pointer as the mitk-image. So you have full read- and write- access to the data vector of the mitk-image using the itk-image. Call by:
va_tuple | A variable length tuple containing the arguments to be passed to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD). |
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
Definition at line 372 of file mitkImageAccessByItk.h.
#define AccessFixedDimensionByItk | ( | mitkImage, | |
itkImageTypeFunction, | |||
dimension | |||
) |
Access a mitk-image with known dimension by an itk-image.
For usage, see AccessByItk.
dimension | Dimension of the mitk-image. If the image has a different dimension, a mitk::AccessByItkException exception is thrown. |
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
Definition at line 277 of file mitkImageAccessByItk.h.
#define AccessFixedDimensionByItk_n | ( | mitkImage, | |
itkImageTypeFunction, | |||
dimension, | |||
va_tuple | |||
) |
Access a mitk-image with known dimension by an itk-image with one or more parameters.
For usage, see AccessByItk_n.
dimension | Dimension of the mitk-image. If the image has a different dimension, a mitk::AccessByItkException exception is thrown. |
va_tuple | A variable length tuple containing the arguments to be passed to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD). |
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
Definition at line 497 of file mitkImageAccessByItk.h.
#define AccessFixedPixelTypeByItk | ( | mitkImage, | |
itkImageTypeFunction, | |||
pixelTypeSeq | |||
) |
Access a mitk-image with known pixeltype (but unknown dimension) by an itk-image.
For usage, see AccessByItk.
pixelTypeSeq | A sequence of pixel types, like (short)(char)(int) |
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
If the image has a different pixel type, a mitk::AccessByItkException exception is thrown. If you do not know the pixel type for sure, use AccessByItk.
Definition at line 213 of file mitkImageAccessByItk.h.
#define AccessFixedPixelTypeByItk_n | ( | mitkImage, | |
itkImageTypeFunction, | |||
pixelTypeSeq, | |||
va_tuple | |||
) |
Access a mitk-image with known pixeltype (but unknown dimension) by an itk-image with one or more parameters.
For usage, see AccessByItk_n.
va_tuple | A variable length tuple containing the arguments to be passed to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD). |
pixelTypeSeq | A sequence of pixel types, like (short)(char)(int). |
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
If the image has a different pixel type, a mitk::AccessByItkException exception is thrown. If you do not know the pixel type for sure, use AccessByItk_n.
Definition at line 400 of file mitkImageAccessByItk.h.
#define AccessFixedTypeByItk | ( | mitkImage, | |
itkImageTypeFunction, | |||
pixelTypeSeq, | |||
dimSeq | |||
) |
Access a mitk-image with known type (pixel type and dimension) by an itk-image.
The provided mitk-image must be in the set of types created by taking the cartesian product of the pixel type sequence and the dimension sequence. For example, a call to
asserts that the type of myMitkImage (pixeltype,dim) is in the set {(short,2),(short,3),(int,2),(int,3)}. For more information, see AccessByItk.
pixelTypeSeq | A sequence of pixel types, like (short)(char)(int). |
dimSeq | A sequence of dimensions, like (2)(3). |
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
If the image has a different dimension or pixel type, a mitk::AccessByItkException exception is thrown.
Definition at line 314 of file mitkImageAccessByItk.h.
#define AccessFixedTypeByItk_n | ( | mitkImage, | |
itkImageTypeFunction, | |||
pixelTypeSeq, | |||
dimSeq, | |||
va_tuple | |||
) |
Access a mitk-image with known type (pixel type and dimension) by an itk-image with one or more parameters.
For usage, see AccessFixedTypeByItk.
pixelTypeSeq | A sequence of pixel types, like (short)(char)(int). |
dimSeq | A sequence of dimensions, like (2)(3). |
va_tuple | A variable length tuple containing the arguments to be passed to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD). |
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
If the image has a different dimension or pixel type, a mitk::AccessByItkException exception is thrown.
Definition at line 554 of file mitkImageAccessByItk.h.
#define AccessTwoImagesFixedDimensionByItk | ( | mitkImage1, | |
mitkImage2, | |||
itkImageTypeFunction, | |||
dimension | |||
) |
Access two mitk-images with known dimension by itk-images.
Define a templated function or method (itkImageTypeFunction) within which the mitk-images (mitkImage1 and mitkImage2) are accessed:
The itk::Image passed to the function/method has the same data-pointer as the mitk-image. So you have full read- and write- access to the data vector of the mitk-image using the itk-image. Call by:
mitkImage1 | The first MITK input image. |
mitkImage2 | The second MITK input image. |
itkImageTypeFunction | The name of the template access-function to be called. |
dimension | Dimension of the two mitk-images. |
mitk::AccessByItkException | If mitkImage1 and mitkImage2 have different dimensions or one of the images is of unsupported pixel type or dimension. |
Definition at line 681 of file mitkImageAccessByItk.h.
#define AccessVectorFixedDimensionByItk_n | ( | mitkImage, | |
itkImageTypeFunction, | |||
dimension, | |||
va_tuple | |||
) |
Access a vector mitk-image with known dimension by a ITK vector image with one or more parameters.
For usage, see AccessByItk_n.
dimension | Dimension of the mitk-image. If the image has a different dimension, a mitk::AccessByItkException exception is thrown. |
va_tuple | A variable length tuple containing the arguments to be passed to the access function itkImageTypeFunction, e.g. ("first", 2, THIRD). |
mitkImage | The MITK input image. |
itkImageTypeFunction | The templated access-function to be called. |
mitk::AccessByItkException | If mitkImage is of unsupported pixel type or dimension. |
Definition at line 523 of file mitkImageAccessByItk.h.
#define InstantiateAccessFunction | ( | itkImgFunc | ) |
Instantiate access function for all datatypes and dimensions.
Definition at line 95 of file mitkInstantiateAccessFunctions.h.
#define InstantiateAccessFunctionForFixedDimension | ( | itkImgFunc, | |
dim | |||
) |
Instantiate access function for all datatypes and a specific dimension.
itkImgFunc | The custom part of the name of the macro to be called. |
dim | a sequence of dimensions, like (2)(3). |
Definition at line 108 of file mitkInstantiateAccessFunctions.h.
#define InstantiateAccessFunctionForFixedPixelType | ( | itkImgFunc, | |
pixelTypeSeq | |||
) |
Instantiate access function for all given pixel types and all dimensions.
itkImgFunc | The custom part of the name of the macro to be called. |
pixelTypeSeq | a sequence of types, like (int)(short)(char). |
Definition at line 121 of file mitkInstantiateAccessFunctions.h.
#define InstantiateAccessFunctionForFixedType | ( | itkImgFunc, | |
pixelTypeSeq, | |||
dimSeq | |||
) |
Instantiate access function for the given pixel types and dimensions.
Iteratively calls a macro named InstantiateAccessFunction_itkImgFunc which you must define and which usually explicitly instantiates your access function.
A call to InstantiateAccessFunctionForFixedPixelType(T, (a)(b), (d)(e)) results in calls
InstantiateAccessFunction_T(a, d)
InstantiateAccessFunction_T(a, e)
InstantiateAccessFunction_T(b, d)
InstantiateAccessFunction_T(b, e)
That is, InstantiateAccessFunction_T is called for the cartesian product of the sequences pixelTypeSeq and dimSeq.
Example:
Use this macro once after the definition of your access function. Some compilers have memory problems without the explicit instantiation. You may need to move the access function to a separate file. The CMake macro MITK_MULTIPLEX_PICTYPE can help you with that. See mitk/CMake/mitkMacroMultiplexPicType.cmake
for documentation.
itkImgFunc | The custom part of the name of the macro to be called. |
pixelTypeSeq | a sequence of types, like (int)(short)(char). |
dimSeq | a sequence of dimensions, like (2)(3). |
Definition at line 85 of file mitkInstantiateAccessFunctions.h.
#define InstantiateAccessFunctionForFloatingPixelTypes | ( | itkImgFunc | ) |
Instantiate access function for floating point datatypes and all dimensions.
itkImgFunc | The custom part of the name of the macro to be called. |
Definition at line 146 of file mitkInstantiateAccessFunctions.h.
#define InstantiateAccessFunctionForIntegralPixelTypes | ( | itkImgFunc | ) |
Instantiate access function for integral datatypes and all dimensions.
itkImgFunc | The custom part of the name of the macro to be called. |
Definition at line 133 of file mitkInstantiateAccessFunctions.h.
void MITKCORE_EXPORT mitk::CastToItkImage | ( | const mitk::Image * | mitkImage, |
itk::SmartPointer< itk::VectorImage< TPixelType, VImageDimension >> & | itkOutputImage | ||
) |
Cast an mitk::Image to an itk::VectorImage with a specific type.
You don't have to initialize the itk::VectorImage<..>::Pointer.
void MITKCORE_EXPORT mitk::CastToItkImage | ( | const mitk::Image * | mitkImage, |
itk::SmartPointer< ItkOutputImageType > & | itkOutputImage | ||
) |
Cast an mitk::Image to an itk::Image with a specific type.
This method casts the pixel types and copies the image memory if necessary. If the requested pixel type is equal to the pixel type of the MITK image, the memory is just referenced.
Usually, you want the ITK image to reference the same image data as the MITK image without any casting. In this case use mitk::ImageToItkImage, which generate less code and is more efficient.
mitkImage | The MITK image to be cast to an ITK image |
itkOutputImage | You don't have to initialize the itk::Image<..>::Pointer. |
Referenced by mitk::CLUtil::Transform().
void mitk::CastToMitkImage | ( | const itk::SmartPointer< ItkOutputImageType > & | itkimage, |
itk::SmartPointer< mitk::Image > & | mitkoutputimage | ||
) |
Cast an itk::Image (with a specific type) to an mitk::Image.
CastToMitkImage does not cast pixel types etc., just image data
Definition at line 74 of file mitkImageCast.h.
Referenced by mitk::CLUtil::itkSampleLabel().
void mitk::CastToMitkImage | ( | const ItkOutputImageType * | itkimage, |
itk::SmartPointer< mitk::Image > & | mitkoutputimage | ||
) |
Cast an itk::Image (with a specific type) to an mitk::Image.
CastToMitkImage does not cast pixel types etc., just image data
Definition at line 88 of file mitkImageCast.h.
References mitk::Image::New().
Image::Pointer mitk::GrabItkImageMemory | ( | itk::SmartPointer< ItkOutputImageType > & | itkimage, |
mitk::Image * | mitkImage = nullptr , |
||
const BaseGeometry * | geometry = nullptr , |
||
bool | update = true |
||
) |
Grabs the memory of an itk::Image (with a specific type) and puts it into an mitk::Image.
The memory is managed by the mitk::Image after calling this function. The itk::Image remains valid until the mitk::Image decides to free the memory.
itkimage | |
mitkImage | |
geometry | |
update | if true, fill mitk::Image, which will execute the up-stream pipeline connected to the input itk::Image. Otherwise you need to make sure that Update() is called on the mitk::Image before its data is being used, e.g., by connecting it to an mitk-pipeline and call Update of a downstream filter at some time. |
Referenced by mitk::CLUtil::Transform().
Image::Pointer mitk::GrabItkImageMemory | ( | ItkOutputImageType * | itkimage, |
mitk::Image * | mitkImage = nullptr , |
||
const BaseGeometry * | geometry = nullptr , |
||
bool | update = true |
||
) |
Grabs the memory of an itk::Image (with a specific type) and puts it into an mitk::Image.
The memory is managed by the mitk::Image after calling this function. The itk::Image remains valid until the mitk::Image decides to free the memory.
itkimage | |
mitkImage | |
geometry | |
update | if true, fill mitk::Image, which will execute the up-stream pipeline connected to the input itk::Image. Otherwise you need to make sure that Update() is called on the mitk::Image before its data is being used, e.g., by connecting it to an mitk-pipeline and call Update of a downstream filter at some time. |
Image::Pointer mitk::GrabItkImageMemoryChannel | ( | ItkOutputImageType * | itkimage, |
const TimeGeometry * | geometry = nullptr , |
||
mitk::Image * | mitkImage = nullptr , |
||
bool | update = true |
||
) |
Grabs the memory of an itk::Image (with a specific type) and puts it into an mitk::Image.
The memory is managed by the mitk::Image after calling this function. The itk::Image remains valid until the mitk::Image decides to free the memory.
itkimage | |
mitkImage | |
geometry | |
update | if true, fill mitk::Image, which will execute the up-stream pipeline connected to the input itk::Image. Otherwise you need to make sure that Update() is called on the mitk::Image before its data is being used, e.g., by connecting it to an mitk-pipeline and call Update of a downstream filter at some time. |
ImageTypeTrait<TPixel, VDimension>::ImageType::ConstPointer mitk::ImageToItkImage | ( | const mitk::Image * | mitkImage | ) |
Convert a MITK image to an ITK image.
This method creates a itk::Image representation for the given MITK image, referencing the MITK image memory. If the provided template arguments do not match the type of the MITK image, an exception is thrown.
The MITK image is locked for read access as long as the returned itk::Image object exists. See ImageToItkImage(mitk::Image*) for read and write access.
TPixel | The pixel type of the ITK image |
VDimension | The image dimension of the ITK image |
mitkImage | The MITK image which is to be converted to an ITK image |
mitk::Exception | if the pixel type or dimension does not match the MITK image type or if the MITK image is already locked for write access. |
Definition at line 167 of file mitkImageToItk.h.
ImageTypeTrait<TPixel, VDimension>::ImageType::Pointer mitk::ImageToItkImage | ( | mitk::Image * | mitkImage | ) |
Convert a MITK image to an ITK image.
This method creates a itk::Image representation for the given MITK image, referencing the MITK image memory. If the provided template arguments do not match the type of the MITK image, an exception is thrown.
The MITK image is locked for read/write access as long as the returned itk::Image object exists. See ImageToItkImage(const mitk::Image*) for read-only access.
TPixel | The pixel type of the ITK image |
VDimension | The image dimension of the ITK image |
mitkImage | The MITK image which is to be converted to an ITK image |
mitk::Exception | if the pixel type or dimension does not match the MITK image type or if the MITK image is already locked for read or write access. |
Definition at line 132 of file mitkImageToItk.h.
Image::Pointer mitk::ImportItkImage | ( | const itk::SmartPointer< ItkOutputImageType > & | itkimage, |
const BaseGeometry * | geometry = nullptr , |
||
bool | update = true |
||
) |
Imports an itk::Image (with a specific type) as an mitk::Image.
Instantiates instance of ITKImageImport. mitk::ITKImageImport does not cast pixel types etc., it just imports image data. If you get a compile error, try image.GetPointer().
itkimage | |
geometry | |
update | if true, fill mitk::Image, which will execute the up-stream pipeline connected to the input itk::Image. Otherwise you need to make sure that Update() is called on the mitk::Image before its data is being used, e.g., by connecting it to an mitk-pipeline and call Update of a downstream filter at some time. |
Referenced by mitk::NonBlockingAlgorithm::SetItkImageAsMITKImagePointerParameter().
Image::Pointer mitk::ImportItkImage | ( | const ItkOutputImageType * | itkimage, |
const BaseGeometry * | geometry = nullptr , |
||
bool | update = true |
||
) |
Imports an itk::Image (with a specific type) as an mitk::Image.
Instantiates instance of ITKImageImport mitk::ITKImageImport does not cast pixel types etc., it just imports image data. If you get a compile error, try image.GetPointer().
itkimage | |
geometry | |
update | if true, fill mitk::Image, which will execute the up-stream pipeline connected to the input itk::Image. Otherwise you need to make sure that Update() is called on the mitk::Image before its data is being used, e.g., by connecting it to an mitk-pipeline and call Update of a downstream filter at some time. |
which calls an ITK-like filter