torchio.data.subject.Subject.get_first_image() - Code Metrics - Inspection of "Add tolerance for numeric checks (#592)" - fepegar/torchio - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1e683c...c93bd0 )

by Fernando

created 2021-08-27 16:33 UTC

torchio.data.subject.Subject.get_first_image() A

↳ Parent: torchio.data.subject

Complexity

Conditions

Size

Total Lines	2
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nop	1
dl	0
loc	2
rs	10
c	0
b	0
f	0

import copy
import pprint
from typing import Any, Dict, List, Tuple, Optional, Sequence, TYPE_CHECKING

import numpy as np

from ..constants import TYPE, INTENSITY
from .image import Image
from ..utils import get_subclasses

if TYPE_CHECKING:
    from ..transforms import Transform, Compose


class Subject(dict):
    """Class to store information about the images corresponding to a subject.

    Args:
        *args: If provided, a dictionary of items.
        **kwargs: Items that will be added to the subject sample.

    Example:

        >>> import torchio as tio
        >>> # One way:
        >>> subject = tio.Subject(
        ...     one_image=tio.ScalarImage('path_to_image.nii.gz'),
        ...     a_segmentation=tio.LabelMap('path_to_seg.nii.gz'),
        ...     age=45,
        ...     name='John Doe',
        ...     hospital='Hospital Juan Negrín',
        ... )
        >>> # If you want to create the mapping before, or have spaces in the keys:
        >>> subject_dict = {
        ...     'one image': tio.ScalarImage('path_to_image.nii.gz'),
        ...     'a segmentation': tio.LabelMap('path_to_seg.nii.gz'),
        ...     'age': 45,
        ...     'name': 'John Doe',
        ...     'hospital': 'Hospital Juan Negrín',
        ... }
        >>> subject = tio.Subject(subject_dict)

    """

    def __init__(self, *args, **kwargs: Dict[str, Any]):
        if args:
            if len(args) == 1 and isinstance(args[0], dict):
                kwargs.update(args[0])
            else:
                message = (
                    'Only one dictionary as positional argument is allowed')
                raise ValueError(message)
        super().__init__(**kwargs)
        self._parse_images(self.get_images(intensity_only=False))
        self.update_attributes()  # this allows me to do e.g. subject.t1
        self.applied_transforms = []

    def __repr__(self):
        num_images = len(self.get_images(intensity_only=False))
        string = (
            f'{self.__class__.__name__}'
            f'(Keys: {tuple(self.keys())}; images: {num_images})'
        )
        return string

    def __copy__(self):
        result_dict = {}
        for key, value in self.items():
            if isinstance(value, Image):
                value = copy.copy(value)
            else:
                value = copy.deepcopy(value)
            result_dict[key] = value
        new = Subject(result_dict)
        new.applied_transforms = self.applied_transforms[:]
        return new

    def __len__(self):
        return len(self.get_images(intensity_only=False))

    @staticmethod
    def _parse_images(images: List[Tuple[str, Image]]) -> None:
        # Check that it's not empty
        if not images:
            raise ValueError('A subject without images cannot be created')

    @property
    def shape(self):
        """Return shape of first image in subject.

        Consistency of shapes across images in the subject is checked first.

        Example::

            >>> import torchio as tio
            >>> colin = tio.datasets.Colin27()
            >>> colin.shape
            (1, 181, 217, 181)

        """
        self.check_consistent_attribute('shape')
        return self.get_first_image().shape

    @property
    def spatial_shape(self):
        """Return spatial shape of first image in subject.

        Consistency of spatial shapes across images in the subject is checked
        first.

        Example::

            >>> import torchio as tio
            >>> colin = tio.datasets.Colin27()
            >>> colin.shape
            (181, 217, 181)
        """
        self.check_consistent_spatial_shape()
        return self.get_first_image().spatial_shape

    @property
    def spacing(self):
        """Return spacing of first image in subject.

        Consistency of spacings across images in the subject is checked first.

        Example::

            >>> import torchio as tio
            >>> colin = tio.datasets.Slicer()
            >>> colin.shape
            (1.0, 1.0, 1.2999954223632812)
        """
        self.check_consistent_attribute('spacing')
        return self.get_first_image().spacing

    @property
    def history(self):
        # Kept for backwards compatibility
        return self.get_applied_transforms()

    def is_2d(self):
        return all(i.is_2d() for i in self.get_images(intensity_only=False))

    def get_applied_transforms(
            self,
            ignore_intensity: bool = False,
            image_interpolation: Optional[str] = None,
            ) -> List['Transform']:
        from ..transforms.transform import Transform
        from ..transforms.intensity_transform import IntensityTransform
        name_to_transform = {
            cls.__name__: cls
            for cls in get_subclasses(Transform)
        }
        transforms_list = []
        for transform_name, arguments in self.applied_transforms:
            transform = name_to_transform[transform_name](**arguments)
            if ignore_intensity and isinstance(transform, IntensityTransform):
                continue
            resamples = hasattr(transform, 'image_interpolation')
            if resamples and image_interpolation is not None:
                parsed = transform.parse_interpolation(image_interpolation)
                transform.image_interpolation = parsed
            transforms_list.append(transform)
        return transforms_list

    def get_composed_history(
            self,
            ignore_intensity: bool = False,
            image_interpolation: Optional[str] = None,
            ) -> 'Compose':
        from ..transforms.augmentation.composition import Compose
        transforms = self.get_applied_transforms(
            ignore_intensity=ignore_intensity,
            image_interpolation=image_interpolation,
        )
        return Compose(transforms)

    def get_inverse_transform(
            self,
            warn: bool = True,
            ignore_intensity: bool = True,
            image_interpolation: Optional[str] = None,
            ) ->  'Compose':
        """Get a reversed list of the inverses of the applied transforms.

        Args:
            warn: Issue a warning if some transforms are not invertible.
            ignore_intensity: If ``True``, all instances of
                :class:`~torchio.transforms.intensity_transform.IntensityTransform`
                will be ignored.
            image_interpolation: Modify interpolation for scalar images inside
                transforms that perform resampling.
        """
        history_transform = self.get_composed_history(
            ignore_intensity=ignore_intensity,
            image_interpolation=image_interpolation,
        )
        inverse_transform = history_transform.inverse(warn=warn)
        return inverse_transform

    def apply_inverse_transform(self, **kwargs) -> 'Subject':
        """Try to apply the inverse of all applied transforms, in reverse order.

        Args:
            **kwargs: Keyword arguments passed on to
                :meth:`~torchio.data.subject.Subject.get_inverse_transform`.
        """
        inverse_transform = self.get_inverse_transform(**kwargs)
        transformed = inverse_transform(self)
        transformed.clear_history()
        return transformed

    def clear_history(self) -> None:
        self.applied_transforms = []

    def check_consistent_attribute(
            self,
            attribute: str,
            relative_tolerance: float = 1e-6,
            absolute_tolerance: float = 1e-6,
            message: Optional[str] = None,
            ) -> None:
        r"""Check for consistency of an attribute across all images.

        Args:
            attribute: Name of the image attribute to check
            relative_tolerance: Relative tolerance for :func:`numpy.allclose()`
            absolute_tolerance: Absolute tolerance for :func:`numpy.allclose()`

        Example:
            >>> import numpy as np
            >>> import torch
            >>> import torchio as tio
            >>> scalars = torch.randn(1, 512, 512, 100)
            >>> mask = torch.tensor(scalars > 0).type(torch.int16)
            >>> af1 = np.eye([0.8, 0.8, 2.50000000000001, 1])
            >>> af2 = np.eye([0.8, 0.8, 2.49999999999999, 1])  # small difference here (e.g. due to different reader)
            >>> subject = tio.Subject(
            ...   image = tio.ScalarImage(tensor=scalars, affine=af1),
            ...   mask = tio.LabelMap(tensor=mask, affine=af2)
            ... )
            >>> subject.check_consistent_attribute('spacing')  # no error as tolerances are > 0

        .. note:: To check that all values for a specific attribute are close
            between all images in the subject, :func:`numpy.allclose()` is used.
            This function returns ``True`` if
            :math:`|a_i - b_i| \leq t_{abs} + t_{rel} * |b_i|`, where
            :math:`a_i` and :math:`b_i` are the :math:`i`-th element of the same
            attribute of two images being compared,
            :math:`t_{abs}` is the ``absolute_tolerance`` and
            :math:`t_{rel}` is the ``relative_tolerance``.
        """
        message = (
            f'More than one value for "{attribute}" found in subject images:'
            '\n{}'
        )

        names_images = self.get_images_dict(intensity_only=False).items()
        try:
            first_attribute = None
            first_image = None

            for image_name, image in names_images:
                if first_attribute is None:
                    first_attribute = getattr(image, attribute)
                    first_image = image_name
                    continue
                current_attribute = getattr(image, attribute)
                all_close = np.allclose(
                    current_attribute,
                    first_attribute,
                    rtol=relative_tolerance,
                    atol=absolute_tolerance,
                )
                if not all_close:
                    message = message.format(
                        pprint.pformat({
                            first_image: first_attribute,
                            image_name: current_attribute
                        }),
                    )
                    raise RuntimeError(message)
        except TypeError:
            # fallback for non-numeric values
            values_dict = {}
            for image_name, image in names_images:
                values_dict[image_name] = getattr(image, attribute)
            num_unique_values = len(set(values_dict.values()))
            if num_unique_values > 1:
                message = message.format(pprint.pformat(values_dict))
                raise RuntimeError(message)

    def check_consistent_spatial_shape(self) -> None:
        self.check_consistent_attribute('spatial_shape')

    def check_consistent_orientation(self) -> None:
        self.check_consistent_attribute('orientation')

    def check_consistent_affine(self):
        self.check_consistent_attribute('affine')

    def check_consistent_space(self):
        self.check_consistent_spatial_shape()
        self.check_consistent_affine()

    def get_images_names(self) -> List[str]:
        return list(self.get_images_dict(intensity_only=False).keys())

    def get_images_dict(
            self,
            intensity_only=True,
            include: Optional[Sequence[str]] = None,
            exclude: Optional[Sequence[str]] = None,
            ) -> Dict[str, Image]:
        images = {}
        for image_name, image in self.items():
            if not isinstance(image, Image):
                continue
            if intensity_only and not image[TYPE] == INTENSITY:
                continue
            if include is not None and image_name not in include:
                continue
            if exclude is not None and image_name in exclude:
                continue
            images[image_name] = image
        return images

    def get_images(
            self,
            intensity_only=True,
            include: Optional[Sequence[str]] = None,
            exclude: Optional[Sequence[str]] = None,
            ) -> List[Image]:
        images_dict = self.get_images_dict(
            intensity_only=intensity_only,
            include=include,
            exclude=exclude,
        )
        return list(images_dict.values())

    def get_first_image(self) -> Image:
        return self.get_images(intensity_only=False)[0]

    # flake8: noqa: F821
    def add_transform(
            self,
            transform: 'Transform',
            parameters_dict: dict,
            ) -> None:
        self.applied_transforms.append((transform.name, parameters_dict))

    def load(self) -> None:
        """Load images in subject on RAM."""
        for image in self.get_images(intensity_only=False):
            image.load()

    def update_attributes(self) -> None:
        # This allows to get images using attribute notation, e.g. subject.t1
        self.__dict__.update(self)

    def add_image(self, image: Image, image_name: str) -> None:
        """Add an image."""
        self[image_name] = image
        self.update_attributes()

    def remove_image(self, image_name: str) -> None:
        """Remove an image."""
        del self[image_name]
        delattr(self, image_name)

    def plot(self, **kwargs) -> None:
        """Plot images using matplotlib.

        Args:
            **kwargs: Keyword arguments that will be passed on to
                :meth:`~torchio.Image.plot`.
        """
        from ..visualization import plot_subject  # avoid circular import
        plot_subject(self, **kwargs)


1			import copy
2			import pprint
3			from typing import Any, Dict, List, Tuple, Optional, Sequence, TYPE_CHECKING
4
5			import numpy as np
6
7			from ..constants import TYPE, INTENSITY
8			from .image import Image
9			from ..utils import get_subclasses
10
11			if TYPE_CHECKING:
12			from ..transforms import Transform, Compose
13
14
15			class Subject(dict):
16			"""Class to store information about the images corresponding to a subject.
17
18			Args:
19			*args: If provided, a dictionary of items.
20			**kwargs: Items that will be added to the subject sample.
21
22			Example:
23
24			>>> import torchio as tio
25			>>> # One way:
26			>>> subject = tio.Subject(
27			... one_image=tio.ScalarImage('path_to_image.nii.gz'),
28			... a_segmentation=tio.LabelMap('path_to_seg.nii.gz'),
29			... age=45,
30			... name='John Doe',
31			... hospital='Hospital Juan Negrín',
32			... )
33			>>> # If you want to create the mapping before, or have spaces in the keys:
34			>>> subject_dict = {
35			... 'one image': tio.ScalarImage('path_to_image.nii.gz'),
36			... 'a segmentation': tio.LabelMap('path_to_seg.nii.gz'),
37			... 'age': 45,
38			... 'name': 'John Doe',
39			... 'hospital': 'Hospital Juan Negrín',
40			... }
41			>>> subject = tio.Subject(subject_dict)
42
43			"""
44
45			def __init__(self, args, *kwargs: Dict[str, Any]):
46			if args:
47			if len(args) == 1 and isinstance(args[0], dict):
48			kwargs.update(args[0])
49			else:
50			message = (
51			'Only one dictionary as positional argument is allowed')
52			raise ValueError(message)
53			super().__init__(**kwargs)
54			self._parse_images(self.get_images(intensity_only=False))
55			self.update_attributes() # this allows me to do e.g. subject.t1
56			self.applied_transforms = []
57
58			def __repr__(self):
59			num_images = len(self.get_images(intensity_only=False))
60			string = (
61			f'{self.__class__.__name__}'
62			f'(Keys: {tuple(self.keys())}; images: {num_images})'
63			)
64			return string
65
66			def __copy__(self):
67			result_dict = {}
68			for key, value in self.items():
69			if isinstance(value, Image):
70			value = copy.copy(value)
71			else:
72			value = copy.deepcopy(value)
73			result_dict[key] = value
74			new = Subject(result_dict)
75			new.applied_transforms = self.applied_transforms[:]
76			return new
77
78			def __len__(self):
79			return len(self.get_images(intensity_only=False))
80
81			@staticmethod
82			def _parse_images(images: List[Tuple[str, Image]]) -> None:
83			# Check that it's not empty
84			if not images:
85			raise ValueError('A subject without images cannot be created')
86
87			@property
88			def shape(self):
89			"""Return shape of first image in subject.
90
91			Consistency of shapes across images in the subject is checked first.
92
93			Example::
94
95			>>> import torchio as tio
96			>>> colin = tio.datasets.Colin27()
97			>>> colin.shape
98			(1, 181, 217, 181)
99
100			"""
101			self.check_consistent_attribute('shape')
102			return self.get_first_image().shape
103
104			@property
105			def spatial_shape(self):
106			"""Return spatial shape of first image in subject.
107
108			Consistency of spatial shapes across images in the subject is checked
109			first.
110
111			Example::
112
113			>>> import torchio as tio
114			>>> colin = tio.datasets.Colin27()
115			>>> colin.shape
116			(181, 217, 181)
117			"""
118			self.check_consistent_spatial_shape()
119			return self.get_first_image().spatial_shape
120
121			@property
122			def spacing(self):
123			"""Return spacing of first image in subject.
124
125			Consistency of spacings across images in the subject is checked first.
126
127			Example::
128
129			>>> import torchio as tio
130			>>> colin = tio.datasets.Slicer()
131			>>> colin.shape
132			(1.0, 1.0, 1.2999954223632812)
133			"""
134			self.check_consistent_attribute('spacing')
135			return self.get_first_image().spacing
136
137			@property
138			def history(self):
139			# Kept for backwards compatibility
140			return self.get_applied_transforms()
141
142			def is_2d(self):
143			return all(i.is_2d() for i in self.get_images(intensity_only=False))
144
145			def get_applied_transforms(
146			self,
147			ignore_intensity: bool = False,
148			image_interpolation: Optional[str] = None,
149			) -> List['Transform']:
150			from ..transforms.transform import Transform
151			from ..transforms.intensity_transform import IntensityTransform
152			name_to_transform = {
153			cls.__name__: cls
154			for cls in get_subclasses(Transform)
155			}
156			transforms_list = []
157			for transform_name, arguments in self.applied_transforms:
158			transform = name_to_transform[transform_name](**arguments)
159			if ignore_intensity and isinstance(transform, IntensityTransform):
160			continue
161			resamples = hasattr(transform, 'image_interpolation')
162			if resamples and image_interpolation is not None:
163			parsed = transform.parse_interpolation(image_interpolation)
164			transform.image_interpolation = parsed
165			transforms_list.append(transform)
166			return transforms_list
167
168			def get_composed_history(
169			self,
170			ignore_intensity: bool = False,
171			image_interpolation: Optional[str] = None,
172			) -> 'Compose':
173			from ..transforms.augmentation.composition import Compose
174			transforms = self.get_applied_transforms(
175			ignore_intensity=ignore_intensity,
176			image_interpolation=image_interpolation,
177			)
178			return Compose(transforms)
179
180			def get_inverse_transform(
181			self,
182			warn: bool = True,
183			ignore_intensity: bool = True,
184			image_interpolation: Optional[str] = None,
185			) -> 'Compose':
186			"""Get a reversed list of the inverses of the applied transforms.
187
188			Args:
189			warn: Issue a warning if some transforms are not invertible.
190			ignore_intensity: If ``True``, all instances of
191			:class:`~torchio.transforms.intensity_transform.IntensityTransform`
192			will be ignored.
193			image_interpolation: Modify interpolation for scalar images inside
194			transforms that perform resampling.
195			"""
196			history_transform = self.get_composed_history(
197			ignore_intensity=ignore_intensity,
198			image_interpolation=image_interpolation,
199			)
200			inverse_transform = history_transform.inverse(warn=warn)
201			return inverse_transform
202
203			def apply_inverse_transform(self, **kwargs) -> 'Subject':
204			"""Try to apply the inverse of all applied transforms, in reverse order.
205
206			Args:
207			**kwargs: Keyword arguments passed on to
208			:meth:`~torchio.data.subject.Subject.get_inverse_transform`.
209			"""
210			inverse_transform = self.get_inverse_transform(**kwargs)
211			transformed = inverse_transform(self)
212			transformed.clear_history()
213			return transformed
214
215			def clear_history(self) -> None:
216			self.applied_transforms = []
217
218			def check_consistent_attribute(
219			self,
220			attribute: str,
221			relative_tolerance: float = 1e-6,
222			absolute_tolerance: float = 1e-6,
223			message: Optional[str] = None,
224			) -> None:
225			r"""Check for consistency of an attribute across all images.
226
227			Args:
228			attribute: Name of the image attribute to check
229			relative_tolerance: Relative tolerance for :func:`numpy.allclose()`
230			absolute_tolerance: Absolute tolerance for :func:`numpy.allclose()`
231
232			Example:
233			>>> import numpy as np
234			>>> import torch
235			>>> import torchio as tio
236			>>> scalars = torch.randn(1, 512, 512, 100)
237			>>> mask = torch.tensor(scalars > 0).type(torch.int16)
238			>>> af1 = np.eye([0.8, 0.8, 2.50000000000001, 1])
239			>>> af2 = np.eye([0.8, 0.8, 2.49999999999999, 1]) # small difference here (e.g. due to different reader)
240			>>> subject = tio.Subject(
241			... image = tio.ScalarImage(tensor=scalars, affine=af1),
242			... mask = tio.LabelMap(tensor=mask, affine=af2)
243			... )
244			>>> subject.check_consistent_attribute('spacing') # no error as tolerances are > 0
245
246			.. note:: To check that all values for a specific attribute are close
247			between all images in the subject, :func:`numpy.allclose()` is used.
248			This function returns ``True`` if
249			:math:`\|a_i - b_i\| \leq t_{abs} + t_{rel} * \|b_i\|`, where
250			:math:`a_i` and :math:`b_i` are the :math:`i`-th element of the same
251			attribute of two images being compared,
252			:math:`t_{abs}` is the ``absolute_tolerance`` and
253			:math:`t_{rel}` is the ``relative_tolerance``.
254			"""
255			message = (
256			f'More than one value for "{attribute}" found in subject images:'
257			'\n{}'
258			)
259
260			names_images = self.get_images_dict(intensity_only=False).items()
261			try:
262			first_attribute = None
263			first_image = None
264
265			for image_name, image in names_images:
266			if first_attribute is None:
267			first_attribute = getattr(image, attribute)
268			first_image = image_name
269			continue
270			current_attribute = getattr(image, attribute)
271			all_close = np.allclose(
272			current_attribute,
273			first_attribute,
274			rtol=relative_tolerance,
275			atol=absolute_tolerance,
276			)
277			if not all_close:
278			message = message.format(
279			pprint.pformat({
280			first_image: first_attribute,
281			image_name: current_attribute
282			}),
283			)
284			raise RuntimeError(message)
285			except TypeError:
286			# fallback for non-numeric values
287			values_dict = {}
288			for image_name, image in names_images:
289			values_dict[image_name] = getattr(image, attribute)
290			num_unique_values = len(set(values_dict.values()))
291			if num_unique_values > 1:
292			message = message.format(pprint.pformat(values_dict))
293			raise RuntimeError(message)
294
295			def check_consistent_spatial_shape(self) -> None:
296			self.check_consistent_attribute('spatial_shape')
297
298			def check_consistent_orientation(self) -> None:
299			self.check_consistent_attribute('orientation')
300
301			def check_consistent_affine(self):
302			self.check_consistent_attribute('affine')
303
304			def check_consistent_space(self):
305			self.check_consistent_spatial_shape()
306			self.check_consistent_affine()
307
308			def get_images_names(self) -> List[str]:
309			return list(self.get_images_dict(intensity_only=False).keys())
310
311			def get_images_dict(
312			self,
313			intensity_only=True,
314			include: Optional[Sequence[str]] = None,
315			exclude: Optional[Sequence[str]] = None,
316			) -> Dict[str, Image]:
317			images = {}
318			for image_name, image in self.items():
319			if not isinstance(image, Image):
320			continue
321			if intensity_only and not image[TYPE] == INTENSITY:
322			continue
323			if include is not None and image_name not in include:
324			continue
325			if exclude is not None and image_name in exclude:
326			continue
327			images[image_name] = image
328			return images
329
330			def get_images(
331			self,
332			intensity_only=True,
333			include: Optional[Sequence[str]] = None,
334			exclude: Optional[Sequence[str]] = None,
335			) -> List[Image]:
336			images_dict = self.get_images_dict(
337			intensity_only=intensity_only,
338			include=include,
339			exclude=exclude,
340			)
341			return list(images_dict.values())
342
343			def get_first_image(self) -> Image:
344			return self.get_images(intensity_only=False)[0]
345
346			# flake8: noqa: F821
347			def add_transform(
348			self,
349			transform: 'Transform',
350			parameters_dict: dict,
351			) -> None:
352			self.applied_transforms.append((transform.name, parameters_dict))
353
354			def load(self) -> None:
355			"""Load images in subject on RAM."""
356			for image in self.get_images(intensity_only=False):
357			image.load()
358
359			def update_attributes(self) -> None:
360			# This allows to get images using attribute notation, e.g. subject.t1
361			self.__dict__.update(self)
362
363			def add_image(self, image: Image, image_name: str) -> None:
364			"""Add an image."""
365			self[image_name] = image
366			self.update_attributes()
367
368			def remove_image(self, image_name: str) -> None:
369			"""Remove an image."""
370			del self[image_name]
371			delattr(self, image_name)
372
373			def plot(self, **kwargs) -> None:
374			"""Plot images using matplotlib.
375
376			Args:
377			**kwargs: Keyword arguments that will be passed on to
378			:meth:`~torchio.Image.plot`.
379			"""
380			from ..visualization import plot_subject # avoid circular import
381			plot_subject(self, **kwargs)
382

fepegar / torchio

Push — master ( 1e683c...c93bd0 )

torchio.data.subject.Subject.get_first_image() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like