tests.transforms.augmentation.test_random_labels_to_image

Complexity

Total Complexity

25

Size/Duplication

Total Lines	136
Duplicated Lines	0 %

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	TestRandomLabelsToImage.test_missing_label_key_and_pv_label_keys()	0	4	2
A	TestRandomLabelsToImage.test_filling_with_binary_pv_label_map()	0	11	1
A	TestRandomLabelsToImage.test_filling()	0	11	1
A	TestRandomLabelsToImage.test_deterministic_simulation_with_pv_label_map()	0	9	1
A	TestRandomLabelsToImage.test_random_simulation()	0	5	1
A	TestRandomLabelsToImage.test_with_both_label_key_and_pv_label_keys()	0	4	2
A	TestRandomLabelsToImage.test_filling_with_pv_label_map()	0	10	1
A	TestRandomLabelsToImage.test_deterministic_simulation()	0	9	1
A	TestRandomLabelsToImage.test_deterministic_simulation_with_binary_pv_label_map()	0	10	1
A	TestRandomLabelsToImage.test_with_bad_default_gaussian_parameters_structure()	0	5	2
A	TestRandomLabelsToImage.test_with_bad_gaussian_parameters_range()	0	4	2
A	TestRandomLabelsToImage.test_with_wrong_label_key_type()	0	4	2
A	TestRandomLabelsToImage.test_with_wrong_pv_label_keys_elements_type()	0	4	2
A	TestRandomLabelsToImage.test_with_wrong_pv_label_keys_type()	0	4	2
A	TestRandomLabelsToImage.test_with_inconsistent_pv_label_maps_affines()	0	10	2
A	TestRandomLabelsToImage.test_with_inconsistent_pv_label_maps_shapes()	0	8	2

import torch
from torchio.transforms import RandomLabelsToImage
from torchio import DATA, AFFINE
from ...utils import TorchioTestCase


class TestRandomLabelsToImage(TorchioTestCase):
    """Tests for `RandomLabelsToImage`."""
    def test_random_simulation(self):
        """The transform runs without error and an 'image' key is present in the transformed sample."""
        transform = RandomLabelsToImage(label_key='label')
        transformed = transform(self.sample)
        self.assertIn('image', transformed)

    def test_deterministic_simulation(self):
        """The transform creates an image where values are equal to given mean if standard deviation is zero.
        Using a label map."""
        transform = RandomLabelsToImage(
            label_key='label',
            gaussian_parameters={1: {'mean': 0.5, 'std': 0}}
        )
        transformed = transform(self.sample)
        self.assertTrue(torch.eq(transformed['image'][DATA] == 0.5, self.sample['label'][DATA] == 1).all())

    def test_deterministic_simulation_with_pv_label_map(self):
        """The transform creates an image where values are equal to given mean if standard deviation is zero.
        Using a PV label map."""
        transform = RandomLabelsToImage(
            pv_label_keys=['label'],
            gaussian_parameters={'label': {'mean': 0.5, 'std': 0}}
        )
        transformed = transform(self.sample)
        self.assertTrue(torch.eq(transformed['image'][DATA] == 0.5, self.sample['label'][DATA] == 1).all())

    def test_deterministic_simulation_with_binary_pv_label_map(self):
        """The transform creates an image where values are equal to given mean if standard deviation is zero.
        Using a binarized PV label map."""
        transform = RandomLabelsToImage(
            pv_label_keys=['label'],
            gaussian_parameters={'label': {'mean': 0.5, 'std': 0}},
            binarize=True
        )
        transformed = transform(self.sample)
        self.assertTrue(torch.eq(transformed['image'][DATA] == 0.5, self.sample['label'][DATA] == 1).all())

    def test_filling(self):
        """The transform can fill in the generated image with an already existing image.
        Using a label map."""
        transform = RandomLabelsToImage(
            label_key='label',
            image_key='t1',
            gaussian_parameters={0: {'mean': 0.0, 'std': 0}}
        )
        t1_indices = self.sample['label'][DATA] == 0
        transformed = transform(self.sample)
        self.assertTrue(torch.eq(transformed['t1'][DATA][t1_indices], self.sample['t1'][DATA][t1_indices]).all())

    def test_filling_with_pv_label_map(self):
        """The transform can fill in the generated image with an already existing image.
        Using a PV label map."""
        transform = RandomLabelsToImage(
            pv_label_keys=['label'],
            image_key='t1'
        )
        t1_indices = self.sample['label'][DATA] == 0
        transformed = transform(self.sample)
        self.assertTrue(torch.eq(transformed['t1'][DATA][t1_indices], self.sample['t1'][DATA][t1_indices]).all())

    def test_filling_with_binary_pv_label_map(self):
        """The transform can fill in the generated image with an already existing image.
        Using a binarized PV label map."""
        transform = RandomLabelsToImage(
            pv_label_keys=['label'],
            image_key='t1',
            binarize=True
        )
        t1_indices = self.sample['label'][DATA] == 0
        transformed = transform(self.sample)
        self.assertTrue(torch.eq(transformed['t1'][DATA][t1_indices], self.sample['t1'][DATA][t1_indices]).all())

    def test_missing_label_key_and_pv_label_keys(self):
        """The transform raises an error if both label_key and pv_label_keys are None."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage()

    def test_with_both_label_key_and_pv_label_keys(self):
        """The transform raises an error if both label_key and pv_label_keys are set."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', pv_label_keys=['label'])

    def test_with_bad_default_gaussian_parameters_structure(self):
        """The transform raises an error if gaussian parameters are not a dictionary
        with keys 'mean' and 'std'."""
        with self.assertRaises(KeyError):
            RandomLabelsToImage(label_key='label', default_gaussian_parameters={'wrong_key': 0})

    def test_with_bad_gaussian_parameters_range(self):
        """The transform raises an error if mean and std are not single values nor tuples of two values."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', default_gaussian_parameters={'mean': [0, 1, 2], 'std': 2})

    def test_with_wrong_label_key_type(self):
        """The transform raises an error if a wrong type is given for label_key."""
        with self.assertRaises(TypeError):
            RandomLabelsToImage(label_key=42)

    def test_with_wrong_pv_label_keys_type(self):
        """The transform raises an error if a wrong type is given for pv_label_keys."""
        with self.assertRaises(TypeError):
            RandomLabelsToImage(pv_label_keys=42)

    def test_with_wrong_pv_label_keys_elements_type(self):
        """The transform raises an error if wrong type are given for pv_label_keys elements."""
        with self.assertRaises(TypeError):
            RandomLabelsToImage(pv_label_keys=[42, 27])

    def test_with_inconsistent_pv_label_maps_shapes(self):
        """The transform raises an error if PV label maps have inconsistent shapes."""
        transform = RandomLabelsToImage(
            pv_label_keys=['label', 'label2'],
        )
        sample = self.get_inconsistent_sample()
        with self.assertRaises(RuntimeError):
            transform(sample)

    def test_with_inconsistent_pv_label_maps_affines(self):
        """The transform raises a warning if PV label maps have inconsistent affines."""
        transform = RandomLabelsToImage(
            pv_label_keys=['label', 'label2'],
        )
        sample = self.get_inconsistent_sample()
        sample['label2'][DATA] = sample['label'][DATA].clone()

The variable DATA does not seem to be defined.

        sample['label2'][AFFINE][0, 0] = -1
        with self.assertRaises(RuntimeWarning):
            transform(sample)