torchio.data.image.Image.__init__() - Code Metrics - Inspection of "Specify axes with anatomical labels" - fepegar/torchio - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#257)

by Fernando

created 2020-08-09 13:12 UTC

torchio.data.image.Image.init() C

↳ Parent: torchio.data.image

Complexity

Conditions

Size

Total Lines	48
Code Lines	37

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	10
eloc	37
nop	9
dl	0
loc	48
rs	5.9999
c	0
b	0
f	0

How to fix Complexity Many Parameters

import warnings
from pathlib import Path
from typing import Any, Dict, Tuple, Optional

import torch
import humanize
import numpy as np
import nibabel as nib
import SimpleITK as sitk

from ..utils import (
    nib_to_sitk,
    get_rotation_and_spacing_from_affine,
    get_stem,
    ensure_4d,
)
from ..torchio import (
    TypeData,
    TypePath,
    TypeTripletInt,
    TypeTripletFloat,
    DATA,
    TYPE,
    AFFINE,
    PATH,
    STEM,
    INTENSITY,
    LABEL,
)
from .io import read_image, write_image


PROTECTED_KEYS = DATA, AFFINE, TYPE, PATH, STEM


class Image(dict):
    r"""TorchIO image.

    For information about medical image orientation, check out `NiBabel docs`_,
    the `3D Slicer wiki`_, `Graham Wideman's website`_, `FSL docs`_ or
    `SimpleITK docs`_.

    Args:
        path: Path to a file that can be read by
            :mod:`SimpleITK` or :mod:`nibabel`, or to a directory containing
            DICOM files. If :py:attr:`tensor` is given, the data in
            :py:attr:`path` will not be read. The data is expected to be 2D or
            3D, and may have multiple channels (see :attr:`num_spatial_dims` and
            :attr:`channels_last`).
        type: Type of image, such as :attr:`torchio.INTENSITY` or
            :attr:`torchio.LABEL`. This will be used by the transforms to
            decide whether to apply an operation, or which interpolation to use
            when resampling. For example, `preprocessing`_ and `augmentation`_
            intensity transforms will only be applied to images with type
            :attr:`torchio.INTENSITY`. Spatial transforms will be applied to
            all types, and nearest neighbor interpolation is always used to
            resample images with type :attr:`torchio.LABEL`.
            The type :attr:`torchio.SAMPLING_MAP` may be used with instances of
            :py:class:`~torchio.data.sampler.weighted.WeightedSampler`.
        tensor: If :py:attr:`path` is not given, :attr:`tensor` must be a 4D
            :py:class:`torch.Tensor` or NumPy array with dimensions
            :math:`(C, D, H, W)`. If it is not 4D, TorchIO will try to guess
            the dimensions meanings. If 2D, the shape will be interpreted as
            :math:`(H, W)`. If 3D, the number of spatial dimensions should be
            determined in :attr:`num_spatial_dims`. If :attr:`num_spatial_dims`
            is not given and the shape is 3 along the first or last dimensions,
            it will be interpreted as a multichannel 2D image. Otherwise, it
            be interpreted as a 3D image with a single channel.
        affine: If :attr:`path` is not given, :attr:`affine` must be a
            :math:`4 \times 4` NumPy array. If ``None``, :attr:`affine` is an
            identity matrix.
        check_nans: If ``True``, issues a warning if NaNs are found
            in the image. If ``False``, images will not be checked for the
            presence of NaNs.
        num_spatial_dims: If ``2`` and the input tensor has 3 dimensions, it
            will be interpreted as a multichannel 2D image. If ``3`` and the
            input has 3 dimensions, it will be interpreted as a
            single-channel 3D volume.
        channels_last: If ``True``, the last dimension of the input will be
            interpreted as the channels. Defaults to ``True`` if :attr:`path` is
            given and ``False`` otherwise.
        **kwargs: Items that will be added to the image dictionary, e.g.
            acquisition parameters.

    Example:
        >>> import torch
        >>> import torchio
        >>> # Loading from a file
        >>> t1_image = torchio.Image('t1.nii.gz', type=torchio.INTENSITY)
        >>> label_image = torchio.Image('t1_seg.nii.gz', type=torchio.LABEL)
        >>> image = torchio.Image(tensor=torch.rand(3, 4, 5))
        >>> image = torchio.Image('safe_image.nrrd', check_nans=False)
        >>> data, affine = image.data, image.affine
        >>> affine.shape
        (4, 4)
        >>> image.data is image[torchio.DATA]
        True
        >>> image.data is image.tensor
        True
        >>> type(image.data)
        torch.Tensor

    TorchIO images are `lazy loaders`_, i.e. the data is only loaded from disk
    when needed.

    Example:
        >>> import torchio
        >>> image = torchio.Image('t1.nii.gz')
        >>> image  # not loaded yet
        Image(path: t1.nii.gz; type: intensity)
        >>> times_two = 2 * image.data  # data is loaded and cached here
        >>> image
        Image(shape: (1, 256, 256, 176); spacing: (1.00, 1.00, 1.00); orientation: PIR+; memory: 44.0 MiB; type: intensity)
        >>> image.save('doubled_image.nii.gz')

    .. _lazy loaders: https://en.wikipedia.org/wiki/Lazy_loading
    .. _preprocessing: https://torchio.readthedocs.io/transforms/preprocessing.html#intensity
    .. _augmentation: https://torchio.readthedocs.io/transforms/augmentation.html#intensity
    .. _NiBabel docs: https://nipy.org/nibabel/image_orientation.html
    .. _3D Slicer wiki: https://www.slicer.org/wiki/Coordinate_systems
    .. _FSL docs: https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/Orientation%20Explained
    .. _SimpleITK docs: https://simpleitk.readthedocs.io/en/master/fundamentalConcepts.html
    .. _Graham Wideman's website: http://www.grahamwideman.com/gw/brain/orientation/orientterms.htm
    """
    def __init__(
            self,
            path: Optional[TypePath] = None,
            type: str = None,
            tensor: Optional[TypeData] = None,
            affine: Optional[TypeData] = None,
            check_nans: bool = True,
            num_spatial_dims: Optional[int] = None,
            channels_last: Optional[bool] = None,
            **kwargs: Dict[str, Any],
            ):
        self.check_nans = check_nans
        self.num_spatial_dims = num_spatial_dims

        if type is None:
            warnings.warn(
                'Not specifying the image type is deprecated and will be'
                ' mandatory in the future. You can probably use ScalarImage or'
                ' LabelMap instead'
            )
            type = INTENSITY

        if path is None and tensor is None:
            raise ValueError('A value for path or tensor must be given')
        self._loaded = False

        # Number of channels are typically stored in the last dimensions in disk
        # But if a tensor is given, the channels should be in the first dim
        if channels_last is None:
            channels_last = path is not None
        self.channels_last = channels_last

        tensor = self.parse_tensor(tensor)
        affine = self.parse_affine(affine)
        if tensor is not None:
            self[DATA] = tensor
            self[AFFINE] = affine
            self._loaded = True
        for key in PROTECTED_KEYS:
            if key in kwargs:
                message = f'Key "{key}" is reserved. Use a different one'
                raise ValueError(message)

        super().__init__(**kwargs)
        self.path = self._parse_path(path)
        self[PATH] = '' if self.path is None else str(self.path)
        self[STEM] = '' if self.path is None else get_stem(self.path)
        self[TYPE] = type

    def __repr__(self):
        properties = []
        if self._loaded:
            properties.extend([
                f'shape: {self.shape}',
                f'spacing: {self.get_spacing_string()}',
                f'orientation: {"".join(self.orientation)}+',
                f'memory: {humanize.naturalsize(self.memory, binary=True)}',
            ])
        else:
            properties.append(f'path: "{self.path}"')
        properties.append(f'type: {self.type}')
        properties = '; '.join(properties)
        string = f'{self.__class__.__name__}({properties})'
        return string

    def __getitem__(self, item):
        if item in (DATA, AFFINE):
            if item not in self:
                self._load()
        return super().__getitem__(item)

    def __array__(self):
        return self[DATA].numpy()

    def __copy__(self):
        kwargs = dict(
            tensor=self.data,
            affine=self.affine,
            type=self.type,
            path=self.path,
            channels_last=False,
        )
        for key, value in self.items():
            if key in PROTECTED_KEYS: continue
            kwargs[key] = value  # should I copy? deepcopy?
        return self.__class__(**kwargs)

    @property
    def data(self):
        return self[DATA]

    @property
    def tensor(self):
        return self.data

    @property
    def affine(self):
        return self[AFFINE]

    @property
    def type(self):
        return self[TYPE]

    @property
    def shape(self) -> Tuple[int, int, int, int]:
        return tuple(self.data.shape)

    @property
    def spatial_shape(self) -> TypeTripletInt:
        return self.shape[1:]

    @property
    def orientation(self):
        return nib.aff2axcodes(self.affine)

    @property
    def spacing(self):
        _, spacing = get_rotation_and_spacing_from_affine(self.affine)
        return tuple(spacing)

    @property
    def memory(self):
        return np.prod(self.shape) * 4  # float32, i.e. 4 bytes per voxel

    def axis_name_to_index(self, axis: str):
        """Convert an axis name to an axis index.

        Args:
            axis: Possible inputs are ``'Left'``, ``'Right'``, ``'Anterior'``,
            ``'Posterior'``, ``'Inferior'``, ``'Superior'``. Lower-case versions
            and first letters are also valid, as only the first letter will be
            used.

        .. note:: If you are working with animals, you should probably use
            ``'Superior'``, ``'Inferior'``, ``'Anterior'`` and ``'Posterior'``
            for ``'Dorsal'``, ``'Ventral'``, ``'Rostral'`` and ``'Caudal'``,
            respectively.
        """
        if not isinstance(axis, str):
            raise ValueError('Axis must be a string')
        axis = axis[0].upper()

        # Generally, TorchIO tensors are (C, D, H, W)
        if axis == 'H':
            return -2
        elif axis == 'W':
            return -1
        else:
            try:
                index = self.orientation.index(axis)
            except ValueError:
                index = self.orientation.index(self.flip_axis(axis))
            # Return negative indices so that it does not matter whether we
            # refer to spatial dimensions or not
            index = -4 + index
            return index

    @staticmethod
    def flip_axis(axis):
        if axis == 'R': return 'L'
        elif axis == 'L': return 'R'
        elif axis == 'A': return 'P'
        elif axis == 'P': return 'A'
        elif axis == 'I': return 'S'
        elif axis == 'S': return 'I'
        else:
            message = (
                f'Axis not understood. Please use a value in {tuple("LRAPIS")}'
            )
            raise ValueError(message)

    def get_spacing_string(self):
        strings = [f'{n:.2f}' for n in self.spacing]
        string = f'({", ".join(strings)})'
        return string

    @staticmethod
    def _parse_path(path: TypePath) -> Path:
        if path is None:
            return None
        try:
            path = Path(path).expanduser()
        except TypeError:
            message = f'Conversion to path not possible for variable: {path}'
            raise TypeError(message)
        if not (path.is_file() or path.is_dir()):  # might be a dir with DICOM
            raise FileNotFoundError(f'File not found: {path}')
        return path

    def parse_tensor(self, tensor: TypeData) -> torch.Tensor:
        if tensor is None:
            return None
        if isinstance(tensor, np.ndarray):
            tensor = torch.from_numpy(tensor)
        tensor = self.parse_tensor_shape(tensor)
        if self.check_nans and torch.isnan(tensor).any():
            warnings.warn(f'NaNs found in tensor')
        return tensor

    def parse_tensor_shape(self, tensor: torch.Tensor) -> torch.Tensor:
        return ensure_4d(tensor, self.channels_last, self.num_spatial_dims)

    @staticmethod
    def parse_affine(affine: np.ndarray) -> np.ndarray:
        if affine is None:
            return np.eye(4)
        if not isinstance(affine, np.ndarray):
            raise TypeError(f'Affine must be a NumPy array, not {type(affine)}')
        if affine.shape != (4, 4):
            raise ValueError(f'Affine shape must be (4, 4), not {affine.shape}')
        return affine

    def _load(self) -> Tuple[torch.Tensor, np.ndarray]:
        r"""Load the image from disk.

        Returns:
            Tuple containing a 4D tensor of size :math:`(C, D, H, W)` and a 2D
            :math:`4 \times 4` affine matrix to convert voxel indices to world
            coordinates.
        """
        if self._loaded:
            return
        tensor, affine = read_image(self.path)
        tensor = self.parse_tensor_shape(tensor)

        if self.check_nans and torch.isnan(tensor).any():
            warnings.warn(f'NaNs found in file "{self.path}"')
        self[DATA] = tensor
        self[AFFINE] = affine
        self._loaded = True

    def save(self, path, squeeze=True, channels_last=True):
        """Save image to disk.

        Args:
            path: String or instance of :py:class:`pathlib.Path`.
            squeeze: If ``True``, the singleton dimensions will be removed
                before saving.
            channels_last: If ``True``, the channels will be saved in the last
                dimension.
        """
        write_image(
            self[DATA],
            self[AFFINE],
            path,
            squeeze=squeeze,
            channels_last=channels_last,
        )

    def is_2d(self) -> bool:
        return self.shape[-3] == 1

    def numpy(self) -> np.ndarray:
        """Get a NumPy array containing the image data."""
        return np.asarray(self)

    def as_sitk(self) -> sitk.Image:
        """Get the image as an instance of :py:class:`sitk.Image`."""
        return nib_to_sitk(self[DATA], self[AFFINE])

    def get_center(self, lps: bool = False) -> TypeTripletFloat:
        """Get image center in RAS+ or LPS+ coordinates.

        Args:
            lps: If ``True``, the coordinates will be in LPS+ orientation, i.e.
                the first dimension grows towards the left, etc. Otherwise, the
                coordinates will be in RAS+ orientation.
        """
        size = np.array(self.spatial_shape)
        center_index = (size - 1) / 2
        r, a, s = nib.affines.apply_affine(self.affine, center_index)
        if lps:
            return (-r, -a, s)
        else:
            return (r, a, s)

    def set_check_nans(self, check_nans: bool):
        self.check_nans = check_nans

    def crop(self, index_ini: TypeTripletInt, index_fin: TypeTripletInt):
        new_origin = nib.affines.apply_affine(self.affine, index_ini)
        new_affine = self.affine.copy()
        new_affine[:3, 3] = new_origin
        i0, j0, k0 = index_ini
        i1, j1, k1 = index_fin
        patch = self.data[:, i0:i1, j0:j1, k0:k1].clone()
        kwargs = dict(
            tensor=patch,
            affine=new_affine,
            type=self.type,
            path=self.path,
            channels_last=False,
        )
        for key, value in self.items():
            if key in PROTECTED_KEYS: continue
            kwargs[key] = value  # should I copy? deepcopy?
        return self.__class__(**kwargs)


class ScalarImage(Image):
    """Alias for :py:class:`~torchio.Image` of type :py:attr:`torchio.INTENSITY`.

    Example:
        >>> import torch
        >>> import torchio
        >>> image = torchio.ScalarImage('t1.nii.gz')  # loading from a file
        >>> image = torchio.ScalarImage(tensor=torch.rand(128, 128, 68))  # from tensor
        >>> data, affine = image.data, image.affine
        >>> affine.shape
        (4, 4)
        >>> image.data is image[torchio.DATA]
        True
        >>> image.data is image.tensor
        True
        >>> type(image.data)
        torch.Tensor

    See :py:class:`~torchio.Image` for more information.

    Raises:
        ValueError: A :py:attr:`type` is used for instantiation.
    """
    def __init__(self, *args, **kwargs):
        if 'type' in kwargs and kwargs['type'] != INTENSITY:
            raise ValueError('Type of ScalarImage is always torchio.INTENSITY')
        kwargs.update({'type': INTENSITY})
        super().__init__(*args, **kwargs)


class LabelMap(Image):
    """Alias for :py:class:`~torchio.Image` of type :py:attr:`torchio.LABEL`.

    Example:
        >>> import torch
        >>> import torchio
        >>> labels = torchio.LabelMap(tensor=torch.rand(128, 128, 68) > 0.5)
        >>> labels = torchio.LabelMap('t1_seg.nii.gz')  # loading from a file

    See :py:class:`~torchio.data.image.Image` for more information.

    Raises:
        ValueError: If a value for :py:attr:`type` is given.
    """
    def __init__(self, *args, **kwargs):
        if 'type' in kwargs and kwargs['type'] != LABEL:
            raise ValueError('Type of LabelMap is always torchio.LABEL')
        kwargs.update({'type': LABEL})
        super().__init__(*args, **kwargs)


1			import warnings
2			from pathlib import Path
3			from typing import Any, Dict, Tuple, Optional
4
5			import torch
6			import humanize
7			import numpy as np
8			import nibabel as nib
9			import SimpleITK as sitk
10
11			from ..utils import (
12			nib_to_sitk,
13			get_rotation_and_spacing_from_affine,
14			get_stem,
15			ensure_4d,
16			)
17			from ..torchio import (
18			TypeData,
19			TypePath,
20			TypeTripletInt,
21			TypeTripletFloat,
22			DATA,
23			TYPE,
24			AFFINE,
25			PATH,
26			STEM,
27			INTENSITY,
28			LABEL,
29			)
30			from .io import read_image, write_image
31
32
33			PROTECTED_KEYS = DATA, AFFINE, TYPE, PATH, STEM
34
35
36			class Image(dict):
37			r"""TorchIO image.
38
39			For information about medical image orientation, check out `NiBabel docs`_,
40			the `3D Slicer wiki`_, `Graham Wideman's website`_, `FSL docs`_ or
41			`SimpleITK docs`_.
42
43			Args:
44			path: Path to a file that can be read by
45			:mod:`SimpleITK` or :mod:`nibabel`, or to a directory containing
46			DICOM files. If :py:attr:`tensor` is given, the data in
47			:py:attr:`path` will not be read. The data is expected to be 2D or
48			3D, and may have multiple channels (see :attr:`num_spatial_dims` and
49			:attr:`channels_last`).
50			type: Type of image, such as :attr:`torchio.INTENSITY` or
51			:attr:`torchio.LABEL`. This will be used by the transforms to
52			decide whether to apply an operation, or which interpolation to use
53			when resampling. For example, `preprocessing`_ and `augmentation`_
54			intensity transforms will only be applied to images with type
55			:attr:`torchio.INTENSITY`. Spatial transforms will be applied to
56			all types, and nearest neighbor interpolation is always used to
57			resample images with type :attr:`torchio.LABEL`.
58			The type :attr:`torchio.SAMPLING_MAP` may be used with instances of
59			:py:class:`~torchio.data.sampler.weighted.WeightedSampler`.
60			tensor: If :py:attr:`path` is not given, :attr:`tensor` must be a 4D
61			:py:class:`torch.Tensor` or NumPy array with dimensions
62			:math:`(C, D, H, W)`. If it is not 4D, TorchIO will try to guess
63			the dimensions meanings. If 2D, the shape will be interpreted as
64			:math:`(H, W)`. If 3D, the number of spatial dimensions should be
65			determined in :attr:`num_spatial_dims`. If :attr:`num_spatial_dims`
66			is not given and the shape is 3 along the first or last dimensions,
67			it will be interpreted as a multichannel 2D image. Otherwise, it
68			be interpreted as a 3D image with a single channel.
69			affine: If :attr:`path` is not given, :attr:`affine` must be a
70			:math:`4 \times 4` NumPy array. If ``None``, :attr:`affine` is an
71			identity matrix.
72			check_nans: If ``True``, issues a warning if NaNs are found
73			in the image. If ``False``, images will not be checked for the
74			presence of NaNs.
75			num_spatial_dims: If ``2`` and the input tensor has 3 dimensions, it
76			will be interpreted as a multichannel 2D image. If ``3`` and the
77			input has 3 dimensions, it will be interpreted as a
78			single-channel 3D volume.
79			channels_last: If ``True``, the last dimension of the input will be
80			interpreted as the channels. Defaults to ``True`` if :attr:`path` is
81			given and ``False`` otherwise.
82			**kwargs: Items that will be added to the image dictionary, e.g.
83			acquisition parameters.
84
85			Example:
86			>>> import torch
87			>>> import torchio
88			>>> # Loading from a file
89			>>> t1_image = torchio.Image('t1.nii.gz', type=torchio.INTENSITY)
90			>>> label_image = torchio.Image('t1_seg.nii.gz', type=torchio.LABEL)
91			>>> image = torchio.Image(tensor=torch.rand(3, 4, 5))
92			>>> image = torchio.Image('safe_image.nrrd', check_nans=False)
93			>>> data, affine = image.data, image.affine
94			>>> affine.shape
95			(4, 4)
96			>>> image.data is image[torchio.DATA]
97			True
98			>>> image.data is image.tensor
99			True
100			>>> type(image.data)
101			torch.Tensor
102
103			TorchIO images are `lazy loaders`_, i.e. the data is only loaded from disk
104			when needed.
105
106			Example:
107			>>> import torchio
108			>>> image = torchio.Image('t1.nii.gz')
109			>>> image # not loaded yet
110			Image(path: t1.nii.gz; type: intensity)
111			>>> times_two = 2 * image.data # data is loaded and cached here
112			>>> image
113			Image(shape: (1, 256, 256, 176); spacing: (1.00, 1.00, 1.00); orientation: PIR+; memory: 44.0 MiB; type: intensity)
114			>>> image.save('doubled_image.nii.gz')
115
116			.. _lazy loaders: https://en.wikipedia.org/wiki/Lazy_loading
117			.. _preprocessing: https://torchio.readthedocs.io/transforms/preprocessing.html#intensity
118			.. _augmentation: https://torchio.readthedocs.io/transforms/augmentation.html#intensity
119			.. _NiBabel docs: https://nipy.org/nibabel/image_orientation.html
120			.. _3D Slicer wiki: https://www.slicer.org/wiki/Coordinate_systems
121			.. _FSL docs: https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/Orientation%20Explained
122			.. _SimpleITK docs: https://simpleitk.readthedocs.io/en/master/fundamentalConcepts.html
123			.. _Graham Wideman's website: http://www.grahamwideman.com/gw/brain/orientation/orientterms.htm
124			"""
125			def __init__(
126			self,
127			path: Optional[TypePath] = None,
128			type: str = None,
129			tensor: Optional[TypeData] = None,
130			affine: Optional[TypeData] = None,
131			check_nans: bool = True,
132			num_spatial_dims: Optional[int] = None,
133			channels_last: Optional[bool] = None,
134			**kwargs: Dict[str, Any],
135			):
136			self.check_nans = check_nans
137			self.num_spatial_dims = num_spatial_dims
138
139			if type is None:
140			warnings.warn(
141			'Not specifying the image type is deprecated and will be'
142			' mandatory in the future. You can probably use ScalarImage or'
143			' LabelMap instead'
144			)
145			type = INTENSITY
146
147			if path is None and tensor is None:
148			raise ValueError('A value for path or tensor must be given')
149			self._loaded = False
150
151			# Number of channels are typically stored in the last dimensions in disk
152			# But if a tensor is given, the channels should be in the first dim
153			if channels_last is None:
154			channels_last = path is not None
155			self.channels_last = channels_last
156
157			tensor = self.parse_tensor(tensor)
158			affine = self.parse_affine(affine)
159			if tensor is not None:
160			self[DATA] = tensor
161			self[AFFINE] = affine
162			self._loaded = True
163			for key in PROTECTED_KEYS:
164			if key in kwargs:
165			message = f'Key "{key}" is reserved. Use a different one'
166			raise ValueError(message)
167
168			super().__init__(**kwargs)
169			self.path = self._parse_path(path)
170			self[PATH] = '' if self.path is None else str(self.path)
171			self[STEM] = '' if self.path is None else get_stem(self.path)
172			self[TYPE] = type
173
174			def __repr__(self):
175			properties = []
176			if self._loaded:
177			properties.extend([
178			f'shape: {self.shape}',
179			f'spacing: {self.get_spacing_string()}',
180			f'orientation: {"".join(self.orientation)}+',
181			f'memory: {humanize.naturalsize(self.memory, binary=True)}',
182			])
183			else:
184			properties.append(f'path: "{self.path}"')
185			properties.append(f'type: {self.type}')
186			properties = '; '.join(properties)
187			string = f'{self.__class__.__name__}({properties})'
188			return string
189
190			def __getitem__(self, item):
191			if item in (DATA, AFFINE):
192			if item not in self:
193			self._load()
194			return super().__getitem__(item)
195
196			def __array__(self):
197			return self[DATA].numpy()
198
199			def __copy__(self):
200			kwargs = dict(
201			tensor=self.data,
202			affine=self.affine,
203			type=self.type,
204			path=self.path,
205			channels_last=False,
206			)
207			for key, value in self.items():
208			if key in PROTECTED_KEYS: continue
209			kwargs[key] = value # should I copy? deepcopy?
210			return self.__class__(**kwargs)
211
212			@property
213			def data(self):
214			return self[DATA]
215
216			@property
217			def tensor(self):
218			return self.data
219
220			@property
221			def affine(self):
222			return self[AFFINE]
223
224			@property
225			def type(self):
226			return self[TYPE]
227
228			@property
229			def shape(self) -> Tuple[int, int, int, int]:
230			return tuple(self.data.shape)
231
232			@property
233			def spatial_shape(self) -> TypeTripletInt:
234			return self.shape[1:]
235
236			@property
237			def orientation(self):
238			return nib.aff2axcodes(self.affine)
239
240			@property
241			def spacing(self):
242			_, spacing = get_rotation_and_spacing_from_affine(self.affine)
243			return tuple(spacing)
244
245			@property
246			def memory(self):
247			return np.prod(self.shape) * 4 # float32, i.e. 4 bytes per voxel
248
249			def axis_name_to_index(self, axis: str):
250			"""Convert an axis name to an axis index.
251
252			Args:
253			axis: Possible inputs are ``'Left'``, ``'Right'``, ``'Anterior'``,
254			``'Posterior'``, ``'Inferior'``, ``'Superior'``. Lower-case versions
255			and first letters are also valid, as only the first letter will be
256			used.
257
258			.. note:: If you are working with animals, you should probably use
259			``'Superior'``, ``'Inferior'``, ``'Anterior'`` and ``'Posterior'``
260			for ``'Dorsal'``, ``'Ventral'``, ``'Rostral'`` and ``'Caudal'``,
261			respectively.
262			"""
263			if not isinstance(axis, str):
264			raise ValueError('Axis must be a string')
265			axis = axis[0].upper()
266
267			# Generally, TorchIO tensors are (C, D, H, W)
268			if axis == 'H':
269			return -2
270			elif axis == 'W':
271			return -1
272			else:
273			try:
274			index = self.orientation.index(axis)
275			except ValueError:
276			index = self.orientation.index(self.flip_axis(axis))
277			# Return negative indices so that it does not matter whether we
278			# refer to spatial dimensions or not
279			index = -4 + index
280			return index
281
282			@staticmethod
283			def flip_axis(axis):
284			if axis == 'R': return 'L'
285			elif axis == 'L': return 'R'
286			elif axis == 'A': return 'P'
287			elif axis == 'P': return 'A'
288			elif axis == 'I': return 'S'
289			elif axis == 'S': return 'I'
290			else:
291			message = (
292			f'Axis not understood. Please use a value in {tuple("LRAPIS")}'
293			)
294			raise ValueError(message)
295
296			def get_spacing_string(self):
297			strings = [f'{n:.2f}' for n in self.spacing]
298			string = f'({", ".join(strings)})'
299			return string
300
301			@staticmethod
302			def _parse_path(path: TypePath) -> Path:
303			if path is None:
304			return None
305			try:
306			path = Path(path).expanduser()
307			except TypeError:
308			message = f'Conversion to path not possible for variable: {path}'
309			raise TypeError(message)
310			if not (path.is_file() or path.is_dir()): # might be a dir with DICOM
311			raise FileNotFoundError(f'File not found: {path}')
312			return path
313
314			def parse_tensor(self, tensor: TypeData) -> torch.Tensor:
315			if tensor is None:
316			return None
317			if isinstance(tensor, np.ndarray):
318			tensor = torch.from_numpy(tensor)
319			tensor = self.parse_tensor_shape(tensor)
320			if self.check_nans and torch.isnan(tensor).any():
321			warnings.warn(f'NaNs found in tensor')
322			return tensor
323
324			def parse_tensor_shape(self, tensor: torch.Tensor) -> torch.Tensor:
325			return ensure_4d(tensor, self.channels_last, self.num_spatial_dims)
326
327			@staticmethod
328			def parse_affine(affine: np.ndarray) -> np.ndarray:
329			if affine is None:
330			return np.eye(4)
331			if not isinstance(affine, np.ndarray):
332			raise TypeError(f'Affine must be a NumPy array, not {type(affine)}')
333			if affine.shape != (4, 4):
334			raise ValueError(f'Affine shape must be (4, 4), not {affine.shape}')
335			return affine
336
337			def _load(self) -> Tuple[torch.Tensor, np.ndarray]:
338			r"""Load the image from disk.
339
340			Returns:
341			Tuple containing a 4D tensor of size :math:`(C, D, H, W)` and a 2D
342			:math:`4 \times 4` affine matrix to convert voxel indices to world
343			coordinates.
344			"""
345			if self._loaded:
346			return
347			tensor, affine = read_image(self.path)
348			tensor = self.parse_tensor_shape(tensor)
349
350			if self.check_nans and torch.isnan(tensor).any():
351			warnings.warn(f'NaNs found in file "{self.path}"')
352			self[DATA] = tensor
353			self[AFFINE] = affine
354			self._loaded = True
355
356			def save(self, path, squeeze=True, channels_last=True):
357			"""Save image to disk.
358
359			Args:
360			path: String or instance of :py:class:`pathlib.Path`.
361			squeeze: If ``True``, the singleton dimensions will be removed
362			before saving.
363			channels_last: If ``True``, the channels will be saved in the last
364			dimension.
365			"""
366			write_image(
367			self[DATA],
368			self[AFFINE],
369			path,
370			squeeze=squeeze,
371			channels_last=channels_last,
372			)
373
374			def is_2d(self) -> bool:
375			return self.shape[-3] == 1
376
377			def numpy(self) -> np.ndarray:
378			"""Get a NumPy array containing the image data."""
379			return np.asarray(self)
380
381			def as_sitk(self) -> sitk.Image:
382			"""Get the image as an instance of :py:class:`sitk.Image`."""
383			return nib_to_sitk(self[DATA], self[AFFINE])
384
385			def get_center(self, lps: bool = False) -> TypeTripletFloat:
386			"""Get image center in RAS+ or LPS+ coordinates.
387
388			Args:
389			lps: If ``True``, the coordinates will be in LPS+ orientation, i.e.
390			the first dimension grows towards the left, etc. Otherwise, the
391			coordinates will be in RAS+ orientation.
392			"""
393			size = np.array(self.spatial_shape)
394			center_index = (size - 1) / 2
395			r, a, s = nib.affines.apply_affine(self.affine, center_index)
396			if lps:
397			return (-r, -a, s)
398			else:
399			return (r, a, s)
400
401			def set_check_nans(self, check_nans: bool):
402			self.check_nans = check_nans
403
404			def crop(self, index_ini: TypeTripletInt, index_fin: TypeTripletInt):
405			new_origin = nib.affines.apply_affine(self.affine, index_ini)
406			new_affine = self.affine.copy()
407			new_affine[:3, 3] = new_origin
408			i0, j0, k0 = index_ini
409			i1, j1, k1 = index_fin
410			patch = self.data[:, i0:i1, j0:j1, k0:k1].clone()
411			kwargs = dict(
412			tensor=patch,
413			affine=new_affine,
414			type=self.type,
415			path=self.path,
416			channels_last=False,
417			)
418			for key, value in self.items():
419			if key in PROTECTED_KEYS: continue
420			kwargs[key] = value # should I copy? deepcopy?
421			return self.__class__(**kwargs)
422
423
424			class ScalarImage(Image):
425			"""Alias for :py:class:`~torchio.Image` of type :py:attr:`torchio.INTENSITY`.
426
427			Example:
428			>>> import torch
429			>>> import torchio
430			>>> image = torchio.ScalarImage('t1.nii.gz') # loading from a file
431			>>> image = torchio.ScalarImage(tensor=torch.rand(128, 128, 68)) # from tensor
432			>>> data, affine = image.data, image.affine
433			>>> affine.shape
434			(4, 4)
435			>>> image.data is image[torchio.DATA]
436			True
437			>>> image.data is image.tensor
438			True
439			>>> type(image.data)
440			torch.Tensor
441
442			See :py:class:`~torchio.Image` for more information.
443
444			Raises:
445			ValueError: A :py:attr:`type` is used for instantiation.
446			"""
447			def __init__(self, args, *kwargs):
448			if 'type' in kwargs and kwargs['type'] != INTENSITY:
449			raise ValueError('Type of ScalarImage is always torchio.INTENSITY')
450			kwargs.update({'type': INTENSITY})
451			super().__init__(args, *kwargs)
452
453
454			class LabelMap(Image):
455			"""Alias for :py:class:`~torchio.Image` of type :py:attr:`torchio.LABEL`.
456
457			Example:
458			>>> import torch
459			>>> import torchio
460			>>> labels = torchio.LabelMap(tensor=torch.rand(128, 128, 68) > 0.5)
461			>>> labels = torchio.LabelMap('t1_seg.nii.gz') # loading from a file
462
463			See :py:class:`~torchio.data.image.Image` for more information.
464
465			Raises:
466			ValueError: If a value for :py:attr:`type` is given.
467			"""
468			def __init__(self, args, *kwargs):
469			if 'type' in kwargs and kwargs['type'] != LABEL:
470			raise ValueError('Type of LabelMap is always torchio.LABEL')
471			kwargs.update({'type': LABEL})
472			super().__init__(args, *kwargs)
473

fepegar / torchio

Pull Request — master (#257)

torchio.data.image.Image.__init__() C

Complexity

Size

Duplication

Importance

How to fix Complexity Many Parameters

Complexity

Many Parameters

Duplication Side-by-Side

Filter issues like

torchio.data.image.Image.init() C