from collections import defaultdict
from typing import Dict
from typing import Iterable
from typing import Tuple
from typing import Union
import numpy as np
import torch
from .. import RandomTransform
from ... import FourierTransform
from ... import IntensityTransform
from ....data.subject import Subject
[docs]class RandomGhosting(RandomTransform, IntensityTransform):
r"""Add random MRI ghosting artifact.
Discrete "ghost" artifacts may occur along the phase-encode direction
whenever the position or signal intensity of imaged structures within the
field-of-view vary or move in a regular (periodic) fashion. Pulsatile flow
of blood or CSF, cardiac motion, and respiratory motion are the most
important patient-related causes of ghost artifacts in clinical MR imaging
(from `mriquestions.com`_).
.. _mriquestions.com: https://mriquestions.com/why-discrete-ghosts.html
Args:
num_ghosts: Number of 'ghosts' :math:`n` in the image.
If :attr:`num_ghosts` is a tuple :math:`(a, b)`, then
:math:`n \sim \mathcal{U}(a, b) \cap \mathbb{N}`.
If only one value :math:`d` is provided,
:math:`n \sim \mathcal{U}(0, d) \cap \mathbb{N}`.
axes: Axis along which the ghosts will be created. If
:attr:`axes` is a tuple, the axis will be randomly chosen
from the passed values. Anatomical labels may also be used (see
:class:`~torchio.transforms.augmentation.RandomFlip`).
intensity: Positive number representing the artifact strength
:math:`s` with respect to the maximum of the :math:`k`-space.
If ``0``, the ghosts will not be visible. If a tuple
:math:`(a, b)` is provided then :math:`s \sim \mathcal{U}(a, b)`.
If only one value :math:`d` is provided,
:math:`s \sim \mathcal{U}(0, d)`.
restore: Number between ``0`` and ``1`` indicating how much of the
:math:`k`-space center should be restored after removing the planes
that generate the artifact.
**kwargs: See :class:`~torchio.transforms.Transform` for additional
keyword arguments.
.. note:: The execution time of this transform does not depend on the
number of ghosts.
"""
def __init__(
self,
num_ghosts: Union[int, Tuple[int, int]] = (4, 10),
axes: Union[int, Tuple[int, ...]] = (0, 1, 2),
intensity: Union[float, Tuple[float, float]] = (0.5, 1),
restore: float = 0.02,
**kwargs
):
super().__init__(**kwargs)
if not isinstance(axes, tuple):
try:
axes = tuple(axes) # type: ignore[arg-type]
except TypeError:
axes = (axes,) # type: ignore[assignment]
assert isinstance(axes, Iterable)
for axis in axes:
if not isinstance(axis, str) and axis not in (0, 1, 2):
raise ValueError(f'Axes must be in (0, 1, 2), not "{axes}"')
self.axes = axes
self.num_ghosts_range = self._parse_range(
num_ghosts, 'num_ghosts', min_constraint=0, type_constraint=int,
)
self.intensity_range = self._parse_range(
intensity, 'intensity_range', min_constraint=0,
)
self.restore = _parse_restore(restore)
def apply_transform(self, subject: Subject) -> Subject:
arguments: Dict[str, dict] = defaultdict(dict)
if any(isinstance(n, str) for n in self.axes):
subject.check_consistent_orientation()
for name, image in self.get_images_dict(subject).items():
is_2d = image.is_2d()
axes = [a for a in self.axes if a != 2] if is_2d else self.axes
min_ghosts, max_ghosts = self.num_ghosts_range
params = self.get_params(
(int(min_ghosts), int(max_ghosts)),
axes, # type: ignore[arg-type]
self.intensity_range,
)
num_ghosts_param, axis_param, intensity_param = params
arguments['num_ghosts'][name] = num_ghosts_param
arguments['axis'][name] = axis_param
arguments['intensity'][name] = intensity_param
arguments['restore'][name] = self.restore
transform = Ghosting(**self.add_include_exclude(arguments))
transformed = transform(subject)
assert isinstance(transformed, Subject)
return transformed
def get_params(
self,
num_ghosts_range: Tuple[int, int],
axes: Tuple[int, ...],
intensity_range: Tuple[float, float],
) -> Tuple:
ng_min, ng_max = num_ghosts_range
num_ghosts = torch.randint(ng_min, ng_max + 1, (1,)).item()
axis = axes[torch.randint(0, len(axes), (1,))]
intensity = self.sample_uniform(*intensity_range)
return num_ghosts, axis, intensity
class Ghosting(IntensityTransform, FourierTransform):
r"""Add MRI ghosting artifact.
Discrete "ghost" artifacts may occur along the phase-encode direction
whenever the position or signal intensity of imaged structures within the
field-of-view vary or move in a regular (periodic) fashion. Pulsatile flow
of blood or CSF, cardiac motion, and respiratory motion are the most
important patient-related causes of ghost artifacts in clinical MR imaging
(from `mriquestions.com`_).
.. _mriquestions.com: http://mriquestions.com/why-discrete-ghosts.html
Args:
num_ghosts: Number of 'ghosts' :math:`n` in the image.
axes: Axis along which the ghosts will be created.
intensity: Positive number representing the artifact strength
:math:`s` with respect to the maximum of the :math:`k`-space.
If ``0``, the ghosts will not be visible.
restore: Number between ``0`` and ``1`` indicating how much of the
:math:`k`-space center should be restored after removing the planes
that generate the artifact.
**kwargs: See :class:`~torchio.transforms.Transform` for additional
keyword arguments.
.. note:: The execution time of this transform does not depend on the
number of ghosts.
"""
def __init__(
self,
num_ghosts: Union[int, Dict[str, int]],
axis: Union[int, Dict[str, int]],
intensity: Union[float, Dict[str, float]],
restore: Union[float, Dict[str, float]],
**kwargs
):
super().__init__(**kwargs)
self.axis = axis
self.num_ghosts = num_ghosts
self.intensity = intensity
self.restore = restore
self.args_names = ['num_ghosts', 'axis', 'intensity', 'restore']
def apply_transform(self, subject: Subject) -> Subject:
axis = self.axis
num_ghosts = self.num_ghosts
intensity = self.intensity
restore = self.restore
for name, image in self.get_images_dict(subject).items():
if self.arguments_are_dict():
assert isinstance(self.axis, dict)
assert isinstance(self.num_ghosts, dict)
assert isinstance(self.intensity, dict)
assert isinstance(self.restore, dict)
axis = self.axis[name]
num_ghosts = self.num_ghosts[name]
intensity = self.intensity[name]
restore = self.restore[name]
transformed_tensors = []
for tensor in image.data:
assert isinstance(num_ghosts, int)
assert isinstance(axis, int)
assert isinstance(intensity, float)
assert isinstance(restore, float)
transformed_tensor = self.add_artifact(
tensor,
num_ghosts,
axis,
intensity,
restore,
)
transformed_tensors.append(transformed_tensor)
image.set_data(torch.stack(transformed_tensors))
return subject
def add_artifact(
self,
tensor: torch.Tensor,
num_ghosts: int,
axis: int,
intensity: float,
restore_center: float,
):
if not num_ghosts or not intensity:
return tensor
spectrum = self.fourier_transform(tensor)
shape = np.array(tensor.shape)
ri, rj, rk = np.round(restore_center * shape).astype(np.uint16)
mi, mj, mk = np.array(tensor.shape) // 2
# Variable "planes" is the part of the spectrum that will be modified
if axis == 0:
planes = spectrum[::num_ghosts, :, :]
restore = spectrum[mi, :, :].clone()
elif axis == 1:
planes = spectrum[:, ::num_ghosts, :]
restore = spectrum[:, mj, :].clone()
elif axis == 2:
planes = spectrum[:, :, ::num_ghosts]
restore = spectrum[:, :, mk].clone()
# Multiply by 0 if intensity is 1
planes *= 1 - intensity
# Restore the center of k-space to avoid extreme artifacts
if axis == 0:
spectrum[mi, :, :] = restore
elif axis == 1:
spectrum[:, mj, :] = restore
elif axis == 2:
spectrum[:, :, mk] = restore
tensor_ghosts = self.inv_fourier_transform(spectrum)
return tensor_ghosts.real.float()
def _parse_restore(restore):
try:
restore = float(restore)
except ValueError as e:
raise TypeError(f'Restore must be a float, not "{restore}"') from e
if not 0 <= restore <= 1:
message = (
f'Restore must be a number between 0 and 1, not {restore}'
)
raise ValueError(message)
return restore