torchio.transforms.augmentation.intensity.random_gamma

Complexity

Total Complexity

4

Size/Duplication

Total Lines	59
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	RandomGamma.__init__()	0	9	1
A	RandomGamma.get_params()	0	4	1
A	RandomGamma.apply_transform()	0	9	2

from typing import Tuple, Optional, List
import torch
from ....torchio import DATA, TypeRangeFloat
from ....data.subject import Subject
from .. import RandomTransform


class RandomGamma(RandomTransform):
    r"""Change contrast of an image by raising its values to the power
    :math:`\gamma`.

    Args:
        log_gamma: Tuple :math:`(a, b)` to compute the exponent
            :math:`\gamma = e ^ \beta`,
            where :math:`\beta \sim \mathcal{U}(a, b)`.
            If a single value :math:`d` is provided, then
            :math:`\beta \sim \mathcal{U}(-d, d)`.
            Negative and positive values for this argument perform gamma
            compression and expansion, respectively.
            See the `Gamma correction`_ Wikipedia entry for more information.
        p: Probability that this transform will be applied.
        seed: See :py:class:`~torchio.transforms.augmentation.RandomTransform`.
        keys: See :py:class:`~torchio.transforms.Transform`.

    .. _Gamma correction: https://en.wikipedia.org/wiki/Gamma_correction

    Example:
        >>> import torchio
        >>> from torchio import RandomGamma
        >>> from torchio.datasets import FPG
        >>> sample = FPG()
        >>> transform = RandomGamma(log_gamma=(-0.3, 0.3))  # gamma between 0.74 and 1.34
        >>> transformed = transform(sample)
    """
    def __init__(
            self,
            log_gamma: TypeRangeFloat = (-0.3, 0.3),
            p: float = 1,
            seed: Optional[int] = None,
            keys: Optional[List[str]] = None,
            ):
        super().__init__(p=p, seed=seed, keys=keys)
        self.log_gamma_range = self.parse_range(log_gamma, 'log_gamma')

    def apply_transform(self, sample: Subject) -> dict:
        random_parameters_images_dict = {}
        for image_name, image_dict in sample.get_images_dict().items():
            gamma = self.get_params(self.log_gamma_range)
            random_parameters_dict = {'gamma': gamma}
            random_parameters_images_dict[image_name] = random_parameters_dict
            image_dict[DATA] = image_dict[DATA] ** gamma

The variable DATA does not seem to be defined.

        sample.add_transform(self, random_parameters_images_dict)
        return sample

    @staticmethod
    def get_params(log_gamma_range: Tuple[float, float]) -> torch.Tensor:
        gamma = torch.FloatTensor(1).uniform_(*log_gamma_range).exp()
        return gamma