pub struct Image { /* private fields */ }Expand description
\class Image \brief The Image class for SimpleITK
This Image class can represent 2D, 3D, and 4D images. The pixel types may be a scalar, a multi-component vector or a run-length-encoded (RLE) “label”. The dimension, pixel type and size is specified at construction.
A fundamental concept of ITK images is that they occupy physical space where the image is defined by an origin, spacing, and direction cosine matrix. The attributes are taken into consideration when doing most operations on an image. A meta-data dictionary is also associated with the image, which may contain additional fields from reading but these attributes are not propagated by image filters.
The SimpleITK Image provides a single facade interface to several ITK image types. Internally, the SimpleITK Image maintains a pointer to the ITK image class, and performs reference counting and lazy copying. This means that deep copying of an image including it’s buffer is delayed until the image is modified. This removes the need to use pointers to SimpleITK Image class, as copying and returning by value do not unnecessarily duplicate the data.
\sa itk::Image itk::VectorImage itk::LabelMap itk::ImageBase
Implementations§
Source§impl Image
impl Image
Sourcepub fn GetITKBase(self: Pin<&mut Self>) -> *mut DataObject
pub fn GetITKBase(self: Pin<&mut Self>) -> *mut DataObject
Get access to internal ITK data object.
The return value should immediately be assigned to as itk::SmartPointer.
In many cases the value may need to be dynamically casted to the actual image type. The GetPixelIDValue() method should return an PixelID which identifies the image type which the DataObject points to.
If this object has been moved, then nullptr is returned.
@{
Source§impl Image
impl Image
Sourcepub fn GetPixelID(&self) -> PixelIDValueEnum
pub fn GetPixelID(&self) -> PixelIDValueEnum
Get the pixel type
The pixel type is set at construction type and can not be manually changed, unless by assignment. The value may be -1 or “Unknown”.
Source§impl Image
impl Image
Sourcepub fn GetDimension(&self) -> c_uint
pub fn GetDimension(&self) -> c_uint
Get the number of physical dimensions.
Only the spatial dimensions are considered here. These are the dimensions the origin, spacing and direction cosine matrix are applicable to. This does not include the pixels’ vector index as a dimension.
Source§impl Image
impl Image
Sourcepub fn GetNumberOfComponentsPerPixel(&self) -> c_uint
pub fn GetNumberOfComponentsPerPixel(&self) -> c_uint
\brief Get the number of components for each pixel
For images with scalar or complex pixel types this method returns one. For images with a vector pixel type the method returns the number of vector components per pixel.
Source§impl Image
impl Image
Sourcepub fn GetNumberOfPixels(&self) -> u64
pub fn GetNumberOfPixels(&self) -> u64
\brief Get the number of pixels in the image
To calculate the total number of values stored continuously for the image’s buffer, the NumberOfPixels should be multiplied by NumberOfComponentsPerPixel in order to account for multiple component images.
Source§impl Image
impl Image
Sourcepub fn GetSizeOfPixelComponent(&self) -> c_uint
pub fn GetSizeOfPixelComponent(&self) -> c_uint
\brief Get the number of bytes per component of a pixel.
Returns the sizeof the pixel component type.
Source§impl Image
impl Image
Sourcepub fn IsCongruentImageGeometry(
&self,
otherImage: &Image,
coordinateTolerance: f64,
directionTolerance: f64,
) -> bool
pub fn IsCongruentImageGeometry( &self, otherImage: &Image, coordinateTolerance: f64, directionTolerance: f64, ) -> bool
Checks whether the images’ pixels at the same index occupy the same physical space.
Compares the origin, spacing, and direction for equality within provided tolerances. There is no check for matching regions in between the images.
If The dimensions of the images do not match, false is returned.
Source§impl Image
impl Image
Sourcepub fn IsSameImageGeometryAs(
&self,
otherImage: &Image,
arg1: f64,
arg2: f64,
) -> bool
pub fn IsSameImageGeometryAs( &self, otherImage: &Image, arg1: f64, arg2: f64, ) -> bool
Check whether the images have the same grid in physical space.
Compares largest possible regions for equality, and the origin, spacing, and direction cosines for equality within provided tolerances.
If the dimensions of the images do not match, false is returned.
Source§impl Image
impl Image
Sourcepub fn CopyInformation(self: Pin<&mut Self>, srcImage: &Image)
pub fn CopyInformation(self: Pin<&mut Self>, srcImage: &Image)
\brief Copy common meta-data from an image to this one.
Copies the Origin, Spacing, and Direction from the source image to this image. The meta-data dictionary is \b not copied.
It is required for the source Image’s dimension and size to match, this image’s attributes, otherwise an exception will be generated.
Source§impl Image
impl Image
Sourcepub fn HasMetaDataKey(&self, key: &CxxString) -> bool
pub fn HasMetaDataKey(&self, key: &CxxString) -> bool
\brief Query the meta-data dictionary for the existence of a key.
Source§impl Image
impl Image
Sourcepub fn SetMetaData(self: Pin<&mut Self>, key: &CxxString, value: &CxxString)
pub fn SetMetaData(self: Pin<&mut Self>, key: &CxxString, value: &CxxString)
\brief Set an entry in the meta-data dictionary.
Replaces or creates an entry in the image’s meta-data dictionary.
Source§impl Image
impl Image
Sourcepub fn EraseMetaData(self: Pin<&mut Self>, key: &CxxString) -> bool
pub fn EraseMetaData(self: Pin<&mut Self>, key: &CxxString) -> bool
\brief Remove an entry from the meta-data dictionary.
Returns true, when the value exists in the dictionary and is removed, false otherwise.
Source§impl Image
impl Image
Sourcepub fn GetPixelAsInt8(&self, idx: &CxxVector<u32>) -> i8
pub fn GetPixelAsInt8(&self, idx: &CxxVector<u32>) -> i8
\brief Get the value of a pixel
Returns the value of a pixel for the given index. The index follows standard SimpleITK conventions for it’s length. The correct method must be called for the underlying Image type, otherwise an exception will be thrown.
\param idx the zero based index into the image. It’s length must be at least the value of GetDimension(), additional elements will be ignored. Boundary checking is performed on idx, if it is out of bounds an exception will be thrown.
\sa Image::GetPixelIDValue @{
Source§impl Image
impl Image
Sourcepub fn SetPixelAsInt8(self: Pin<&mut Self>, idx: &CxxVector<u32>, v: i8)
pub fn SetPixelAsInt8(self: Pin<&mut Self>, idx: &CxxVector<u32>, v: i8)
\brief Set the value of a pixel
Set the value of a pixel at the provided index. The index follows standard SimpleITK conventions for it’s length. The correct method must be called which should match the underlying image type, otherwise an exception will be thrown.
\param idx the zero based index into the image. It’s length must be at least the value of GetDimension(), additional elements will be ignored. Boundary checking is performed on idx, if it is out of bounds an exception will be thrown. \param v value to set the pixel to
\sa Image::GetPixelIDValue @{
Source§impl Image
impl Image
Sourcepub fn GetBufferAsInt8(self: Pin<&mut Self>) -> *mut i8
pub fn GetBufferAsInt8(self: Pin<&mut Self>) -> *mut i8
\brief Get a pointer to the image buffer \warning this is dangerous
The size of the buffer is the number of componentsXsizeYsize and then Zsize of a 3D image. The buffer should be accessed as a 1-D array. For example a 3D image buffer should be accessed: \code uint8_t buffer = img->GetBufferAsUInt8(); buffer[c + numComponents(x+xSize*(y+ySize*z))] \endcode
The pointer to the buffer is not referenced counted. Additionally, while this image is made unique before returning the pointer, additional copying and usage may introduce unexpected aliasing of the image’s buffer.
Vector and Complex pixel types are both accessed via the appropriate component type method.
The correct method for the current pixel type of the image must be called or else an exception will be generated. For vector pixel types the type of the component of the vector must be called.
\sa Image::GetPixelIDValue @{
Source§impl Image
impl Image
Sourcepub fn MakeUnique(self: Pin<&mut Self>)
pub fn MakeUnique(self: Pin<&mut Self>)
\brief Performs actually coping if needed to make object unique.
The Image class by default performs lazy coping and assignment. This method make sure that coping actually happens to the itk::Image pointed to is only pointed to by this object.
Source§impl Image
impl Image
Sourcepub fn ProxyForInPlaceOperation<'a>(
self: Pin<&'a mut Image>,
) -> impl New<Output = Image> + 'a
pub fn ProxyForInPlaceOperation<'a>( self: Pin<&'a mut Image>, ) -> impl New<Output = Image> + 'a
\brief Advanced method not commonly needed
This method is designed to support implementations “in-place” object behavior for methods which operate on r-value references. The returned image is a new image which has a low level pointer to this object’s image buffer, without the SimpleITK or ITK reference counting. This is implemented by setting the new ITK Image’s buffer to the same as this objects without ownership.
\warning This method bypasses the SimpleITK reference counting, and the reference needs to be manually maintained in the scope. The resulting object is designed only to be a temporary.
In the following example this method is used instead of an std::move call when the filter’s first argument
takes an r-value reference. The img object will container the results of the filter execution, and the img
image buffer will be preserved in case of exceptions, and the meta-data will remain in the img object.
\code
filter.Execute( img.ProxyForInPlaceOperation() );
\endcode
The meta-data dictionary is not copied to the returned proxy image.
Sourcepub fn GetPixelIDTypeAsString(self: &Image) -> UniquePtr<CxxString> ⓘ
pub fn GetPixelIDTypeAsString(self: &Image) -> UniquePtr<CxxString> ⓘ
Return the pixel type as a human readable string value.
Sourcepub fn GetOrigin(self: &Image) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn GetOrigin(self: &Image) -> UniquePtr<CxxVector<f64>> ⓘ
Get/Set the Origin in physical space @{
Sourcepub fn GetSpacing(self: &Image) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn GetSpacing(self: &Image) -> UniquePtr<CxxVector<f64>> ⓘ
Get/Set the Spacing of the Image as an std::vector .
The spacing describes the physical size of each pixel. The length of the vector is equal to the dimension of the Image. @{
Sourcepub fn GetDirection(self: &Image) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn GetDirection(self: &Image) -> UniquePtr<CxxVector<f64>> ⓘ
\brief Set/Get the Direction
Internally, the Direction is represented by a matrix 2x2 for a 2D and 3x3 for a 3D image. The matrix is passed as a 1D array in row-major form. @{
Sourcepub fn TransformIndexToPhysicalPoint(
self: &Image,
index: &CxxVector<i64>,
) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn TransformIndexToPhysicalPoint( self: &Image, index: &CxxVector<i64>, ) -> UniquePtr<CxxVector<f64>> ⓘ
Transform index to physical point
Sourcepub fn TransformPhysicalPointToIndex(
self: &Image,
point: &CxxVector<f64>,
) -> UniquePtr<CxxVector<i64>> ⓘ
pub fn TransformPhysicalPointToIndex( self: &Image, point: &CxxVector<f64>, ) -> UniquePtr<CxxVector<i64>> ⓘ
Transform physical point to index
Sourcepub fn TransformPhysicalPointToContinuousIndex(
self: &Image,
point: &CxxVector<f64>,
) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn TransformPhysicalPointToContinuousIndex( self: &Image, point: &CxxVector<f64>, ) -> UniquePtr<CxxVector<f64>> ⓘ
Transform physical point to continuous index
Sourcepub fn TransformContinuousIndexToPhysicalPoint(
self: &Image,
index: &CxxVector<f64>,
) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn TransformContinuousIndexToPhysicalPoint( self: &Image, index: &CxxVector<f64>, ) -> UniquePtr<CxxVector<f64>> ⓘ
Transform continuous index to physical point
Sourcepub fn EvaluateAtContinuousIndex(
self: &Image,
index: &CxxVector<f64>,
interp: InterpolatorEnum,
) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn EvaluateAtContinuousIndex( self: &Image, index: &CxxVector<f64>, interp: InterpolatorEnum, ) -> UniquePtr<CxxVector<f64>> ⓘ
\brief Interpolate pixel value at a continuous index.
This method is not supported for Label pixel types.
The valid range of continuous index is [-0.5, size-0.5] for each dimension. An exception is thrown if index is out of bounds.
@param index The continuous index must be at least the length of the image dimension. @param interp The interpolation type to use, only sitkNearest and sitkLinear are supported for Vector and Complex pixel types.
@return All supported pixel types are returned as an array, where complex numbers are returned with the real followed by the complex component.
Sourcepub fn EvaluateAtPhysicalPoint(
self: &Image,
point: &CxxVector<f64>,
interp: InterpolatorEnum,
) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn EvaluateAtPhysicalPoint( self: &Image, point: &CxxVector<f64>, interp: InterpolatorEnum, ) -> UniquePtr<CxxVector<f64>> ⓘ
Interpolate pixel value at a physical point.
This method is not supported for Label pixel types.
An exception is thrown if the point is out of the defined region for the image.
@param point The physical point at which the interpolation is computed. @param interp The interpolation type to use, only sitkNearest and sitkLinear are supported for Vector and Complex pixel types.
@return All supported pixel types are returned as an array, where complex numbers are returned with the real followed by the complex component.
Sourcepub fn GetMetaDataKeys(self: &Image) -> UniquePtr<CxxVector<CxxString>> ⓘ
pub fn GetMetaDataKeys(self: &Image) -> UniquePtr<CxxVector<CxxString>> ⓘ
\brief get a vector of keys in from the meta-data dictionary
Returns a vector of keys to the key/value entries in the image’s meta-data dictionary. Iterate through with these keys to get the values.
Sourcepub fn GetMetaData(self: &Image, key: &CxxString) -> UniquePtr<CxxString> ⓘ
pub fn GetMetaData(self: &Image, key: &CxxString) -> UniquePtr<CxxString> ⓘ
\brief Get the value of a meta-data dictionary entry as a string.
If the key is not in the dictionary then an exception is thrown.
string types in the dictionary are returned as their native strings. Other types are printed to string before returning.
pub fn ToString(self: &Image) -> UniquePtr<CxxString> ⓘ
Sourcepub fn ToVectorImage<'a>(
self: Pin<&'a mut Image>,
inPlace: bool,
) -> impl New<Output = Image> + 'a
pub fn ToVectorImage<'a>( self: Pin<&'a mut Image>, inPlace: bool, ) -> impl New<Output = Image> + 'a
\brief Convert the first dimension to the components for image with vector pixel type.
This method will convert a scalar image to a vector image with the number of components equal to the size of the first dimension. If the image is already a vector image then the image is returned.
The components of the direction cosine matrix for the first dimension must be the identity matrix, or else an exception is thrown.
An exception is thrown if the image is 2D or if the pixel type is a label or complex pixel type.
\param inPlace If true then the image is made unique and converted in place updating this image, otherwise a copy of the image is made and returned.
\sa ToScalarImage
Sourcepub fn ToScalarImage<'a>(
self: Pin<&'a mut Image>,
inPlace: bool,
) -> impl New<Output = Image> + 'a
pub fn ToScalarImage<'a>( self: Pin<&'a mut Image>, inPlace: bool, ) -> impl New<Output = Image> + 'a
\brief Convert a image of vector pixel type to a scalar image with N+1 dimensions.
This method will convert a vector image to a scalar image with the size of the first dimension equal to the number of components. If the image is already a scalar image then the image is returned.
For the additional dimension the origin is set to zero, the spacing to one, and the new components of the direction cosine to the identity matrix.
An exception is thrown if the image is has SITK_MAX_DIMENSION dimensions or if the pixel type is a label or complex pixel type.
\param inPlace If true then the image is made unique and converted in place updating this image, otherwise a copy of the image is made and returned.
\sa ToVectorImage
pub fn GetPixelAsVectorInt8( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<i8>> ⓘ
pub fn GetPixelAsVectorUInt8( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<u8>> ⓘ
pub fn GetPixelAsVectorInt16( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<i16>> ⓘ
pub fn GetPixelAsVectorUInt16( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<u16>> ⓘ
pub fn GetPixelAsVectorInt32( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<i32>> ⓘ
pub fn GetPixelAsVectorUInt32( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<u32>> ⓘ
pub fn GetPixelAsVectorInt64( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<i64>> ⓘ
pub fn GetPixelAsVectorUInt64( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<u64>> ⓘ
pub fn GetPixelAsVectorFloat32( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<f32>> ⓘ
pub fn GetPixelAsVectorFloat64( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<CxxVector<f64>> ⓘ
pub fn GetPixelAsComplexFloat32( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<std_complex_float_AutocxxConcrete> ⓘ
pub fn GetPixelAsComplexFloat64( self: &Image, idx: &CxxVector<u32>, ) -> UniquePtr<std_complex_double_AutocxxConcrete> ⓘ
pub fn SetPixelAsComplexFloat32( self: Pin<&mut Image>, idx: &CxxVector<u32>, v: impl ValueParam<std_complex_float_AutocxxConcrete>, )
pub fn SetPixelAsComplexFloat64( self: Pin<&mut Image>, idx: &CxxVector<u32>, v: impl ValueParam<std_complex_double_AutocxxConcrete>, )
Sourcepub fn new3(
width: c_uint,
height: c_uint,
valueEnum: PixelIDValueEnum,
) -> impl New<Output = Self>
pub fn new3( width: c_uint, height: c_uint, valueEnum: PixelIDValueEnum, ) -> impl New<Output = Self>
\brief Constructors for 2D, 3D an optionally 4D images where pixel type and number of components can be specified.
If the pixel type is a scalar or a label pixel type, then the number of components must be specified as 0 or 1.
If the pixel type is a vector pixel type, then the number of components defaults to the image dimension, unless the numberOfComponents is explicitly specified.
Unlike the standard convention for Dimensional Vectors the size parameter must be the exact dimension requesting. That is, it must be of length 2 of a 2D image, 3 for a 3D image and 4 for a 4D image. @{