tests.transforms.augmentation.test_random_labels_to_image

Complexity

Total Complexity

43

Size/Duplication

Total Lines	252
Duplicated Lines	13.89 %

Importance

Changes

0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	TestRandomLabelsToImage.test_random_simulation()	0	6	1
A	TestRandomLabelsToImage.test_deterministic_simulation_with_discretized_label_map()	18	18	1
A	TestRandomLabelsToImage.test_deterministic_simulation()	17	17	1
A	TestRandomLabelsToImage.test_filling_without_any_hole()	0	11	1
A	TestRandomLabelsToImage.test_filling_with_discretized_label_map()	0	15	1
A	TestRandomLabelsToImage.test_with_bad_default_mean_type()	0	4	2
A	TestRandomLabelsToImage.test_with_wrong_label_key_type()	0	5	2
A	TestRandomLabelsToImage.test_with_wrong_used_labels_elements_type()	0	5	2
A	TestRandomLabelsToImage.test_with_wrong_used_labels_type()	0	5	2
A	TestRandomLabelsToImage.test_missing_label_key()	0	4	2
A	TestRandomLabelsToImage.test_mean_and_std_len_not_matching()	0	4	2
A	TestRandomLabelsToImage.test_filling_with_discretized_pv_label_map()	0	16	1
A	TestRandomLabelsToImage.test_mean_and_used_labels_len_not_matching()	0	5	2
A	TestRandomLabelsToImage.test_deterministic_simulation_with_pv_map()	0	17	1
A	TestRandomLabelsToImage.test_filling()	0	14	1
A	TestRandomLabelsToImage.test_with_bad_default_std_type()	0	4	2
A	TestRandomLabelsToImage.test_with_bad_default_mean_range()	0	5	2
A	TestRandomLabelsToImage.test_with_wrong_mean_type()	0	4	2
A	TestRandomLabelsToImage.test_with_wrong_std_type()	0	4	2
A	TestRandomLabelsToImage.test_mean_not_matching_number_of_labels()	0	6	2
A	TestRandomLabelsToImage.test_std_and_used_labels_len_not_matching()	0	5	2
A	TestRandomLabelsToImage.test_with_wrong_std_elements_type()	0	5	2
A	TestRandomLabelsToImage.test_std_not_matching_number_of_labels()	0	6	2
A	TestRandomLabelsToImage.test_deterministic_simulation_with_discretized_pv_map()	0	15	1
A	TestRandomLabelsToImage.test_with_wrong_mean_elements_type()	0	5	2
A	TestRandomLabelsToImage.test_with_bad_default_std_range()	0	5	2

import numpy as np
from torchio.transforms import RandomLabelsToImage
from torchio import DATA
from ...utils import TorchioTestCase
from numpy.testing import assert_array_equal


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

    def test_deterministic_simulation(self):

This code seems to be duplicated in your project.

        """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',
            mean=[0.5, 2],
            std=[0, 0]
        )
        transformed = transform(self.sample)
        assert_array_equal(
            transformed['image_from_labels'][DATA] == 0.5,
            self.sample['label'][DATA] == 0
        )
        assert_array_equal(
            transformed['image_from_labels'][DATA] == 2,
            self.sample['label'][DATA] == 1
        )

    def test_deterministic_simulation_with_discretized_label_map(self):

This code seems to be duplicated in your project.

        """The transform creates an image where values are equal to given mean
        if standard deviation is zero.
        Using a discretized label map."""
        transform = RandomLabelsToImage(
            label_key='label',
            mean=[0.5, 2],
            std=[0, 0],
            discretize=True
        )
        transformed = transform(self.sample)
        assert_array_equal(
            transformed['image_from_labels'][DATA] == 0.5,
            self.sample['label'][DATA] == 0
        )
        assert_array_equal(
            transformed['image_from_labels'][DATA] == 2,
            self.sample['label'][DATA] == 1
        )

    def test_deterministic_simulation_with_pv_map(self):
        """The transform creates an image where values are equal to given
        mean weighted by partial-volume if standard deviation is zero."""
        sample = self.get_sample_with_partial_volume_label_map(components=2)
        transform = RandomLabelsToImage(
            label_key='label',
            mean=[0.5, 1],
            std=[0, 0]
        )
        transformed = transform(sample)
        assert_array_equal(
            transformed['image_from_labels'][DATA][0],
            sample['label'][DATA][0] * 0.5 + sample['label'][DATA][1] * 1
        )
        self.assertEqual(
            transformed['image_from_labels'][DATA].shape,
            (1, 10, 20, 30)
        )

    def test_deterministic_simulation_with_discretized_pv_map(self):
        """The transform creates an image where values are equal to given mean
        if standard deviation is zero.
        Using a discretized partial-volume label map."""
        sample = self.get_sample_with_partial_volume_label_map()
        transform = RandomLabelsToImage(
            label_key='label',
            mean=[0.5],
            std=[0],
            discretize=True
        )
        transformed = transform(sample)
        assert_array_equal(
            transformed['image_from_labels'][DATA],
            (sample['label'][DATA] > 0) * 0.5
        )

    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',
            used_labels=[1]
        )
        t1_indices = self.sample['label'][DATA] == 0
        transformed = transform(self.sample)
        assert_array_equal(
            transformed['t1'][DATA][t1_indices],
            self.sample['t1'][DATA][t1_indices]
        )

    def test_filling_with_discretized_label_map(self):
        """The transform can fill in the generated image with an already
        existing image.
        Using a discretized label map."""
        transform = RandomLabelsToImage(
            label_key='label',
            image_key='t1',
            discretize=True,
            used_labels=[1]
        )
        t1_indices = self.sample['label'][DATA] < 0.5
        transformed = transform(self.sample)
        assert_array_equal(
            transformed['t1'][DATA][t1_indices],
            self.sample['t1'][DATA][t1_indices]
        )

    def test_filling_with_discretized_pv_label_map(self):
        """The transform can fill in the generated image with an already
        existing image.
        Using a discretized partial-volume label map."""
        sample = self.get_sample_with_partial_volume_label_map(components=2)
        transform = RandomLabelsToImage(
            label_key='label',
            image_key='t1',
            discretize=True,
            used_labels=[1]
        )
        t1_indices = sample['label'][DATA].argmax(dim=0) == 0
        transformed = transform(sample)
        assert_array_equal(
            transformed['t1'][DATA][0][t1_indices],
            sample['t1'][DATA][0][t1_indices]
        )

    def test_filling_without_any_hole(self):
        """The transform does not fill anything if there is no hole."""
        transform = RandomLabelsToImage(
            label_key='label',
            image_key='t1',
            default_std=0.,
            default_mean=-1.
        )
        original_t1 = self.sample.t1.data.clone()
        transformed = transform(self.sample)
        assert np.not_equal(original_t1, transformed.t1.data).all()

    def test_missing_label_key(self):
        """The transform raises an error if no label_key is given."""
        with self.assertRaises(TypeError):
            RandomLabelsToImage()

    def test_with_bad_default_mean_range(self):
        """The transform raises an error if default_mean is not a
        single value nor a tuple of two values."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', default_mean=(0, 1, 2))

    def test_with_bad_default_mean_type(self):
        """The transform raises an error if default_mean has the wrong type."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', default_mean='wrong')

    def test_with_bad_default_std_range(self):
        """The transform raises an error if default_std is not a
        single value nor a tuple of two values."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', default_std=(0, 1, 2))

    def test_with_bad_default_std_type(self):
        """The transform raises an error if default_std has the wrong type."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', default_std='wrong')

    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_used_labels_type(self):
        """The transform raises an error if a wrong type is given for
        used_labels."""
        with self.assertRaises(TypeError):
            RandomLabelsToImage(label_key='label', used_labels=42)

    def test_with_wrong_used_labels_elements_type(self):
        """The transform raises an error if wrong type are given for
        used_labels elements."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', used_labels=['wrong'])

    def test_with_wrong_mean_type(self):
        """The transform raises an error if wrong type is given for mean."""
        with self.assertRaises(TypeError):
            RandomLabelsToImage(label_key='label', mean=42)

    def test_with_wrong_mean_elements_type(self):
        """The transform raises an error if wrong type are given for
        mean elements."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', mean=['wrong'])

    def test_with_wrong_std_type(self):
        """The transform raises an error if wrong type is given for std."""
        with self.assertRaises(TypeError):
            RandomLabelsToImage(label_key='label', std=42)

    def test_with_wrong_std_elements_type(self):
        """The transform raises an error if wrong type are given for
        std elements."""
        with self.assertRaises(ValueError):
            RandomLabelsToImage(label_key='label', std=['wrong'])

    def test_mean_and_std_len_not_matching(self):
        """The transform raises an error if mean and std length don't match."""
        with self.assertRaises(AssertionError):
            RandomLabelsToImage(label_key='label', mean=[0], std=[0, 1])

    def test_mean_and_used_labels_len_not_matching(self):
        """The transform raises an error if mean and used_labels
         length don't match."""
        with self.assertRaises(AssertionError):
            RandomLabelsToImage(label_key='label', mean=[0], used_labels=[0, 1])

    def test_std_and_used_labels_len_not_matching(self):
        """The transform raises an error if std and used_labels
         length don't match."""
        with self.assertRaises(AssertionError):
            RandomLabelsToImage(label_key='label', std=[0], used_labels=[0, 1])

    def test_mean_not_matching_number_of_labels(self):
        """The transform raises an error at runtime if mean length
        does not match label numbers."""
        transform = RandomLabelsToImage(label_key='label', mean=[0])
        with self.assertRaises(AssertionError):
            transform(self.sample)

    def test_std_not_matching_number_of_labels(self):
        """The transform raises an error at runtime if std length
        does not match label numbers."""
        transform = RandomLabelsToImage(label_key='label', std=[1, 2, 3])
        with self.assertRaises(AssertionError):
            transform(self.sample)