Exemple #1
0
 def test_values(self):
     datalist = [
         {
             "image": "spleen_19.nii.gz",
             "label": "spleen_label_19.nii.gz"
         },
         {
             "image": "spleen_31.nii.gz",
             "label": "spleen_label_31.nii.gz"
         },
     ]
     transform = Compose([
         DataStatsd(keys=["image", "label"],
                    data_shape=False,
                    value_range=False,
                    data_value=True),
         SimulateDelayd(keys=["image", "label"], delay_time=0.1),
     ])
     dataset = CacheDataset(data=datalist,
                            transform=transform,
                            cache_rate=0.5,
                            cache_num=1)
     dataloader = DataLoader(dataset=dataset, batch_size=2, num_workers=2)
     for d in dataloader:
         self.assertEqual(d["image"][0], "spleen_19.nii.gz")
         self.assertEqual(d["image"][1], "spleen_31.nii.gz")
         self.assertEqual(d["label"][0], "spleen_label_19.nii.gz")
         self.assertEqual(d["label"][1], "spleen_label_31.nii.gz")
Exemple #2
0
    def test_shape(self):
        expected_shape = (128, 128, 128)
        test_image = nib.Nifti1Image(
            np.random.randint(0, 2, size=[128, 128, 128]), np.eye(4))
        test_data = []
        with tempfile.TemporaryDirectory() as tempdir:
            for i in range(6):
                nib.save(test_image,
                         os.path.join(tempdir, f"test_image{str(i)}.nii.gz"))
                test_data.append(
                    {"image": os.path.join(tempdir, f"test_image{i}.nii.gz")})

            test_transform = Compose([
                LoadImaged(keys="image"),
                SimulateDelayd(keys="image", delay_time=1e-7)
            ])

            data_iterator = _Stream(test_data)
            with self.assertRaises(TypeError):  # Dataset doesn't work
                dataset = Dataset(data=data_iterator, transform=test_transform)
                for _ in dataset:
                    pass
            dataset = IterableDataset(data=data_iterator,
                                      transform=test_transform)
            for d in dataset:
                self.assertTupleEqual(d["image"].shape, expected_shape)

            num_workers = 2 if sys.platform == "linux" else 0
            dataloader = DataLoader(dataset=dataset,
                                    batch_size=3,
                                    num_workers=num_workers)
            for d in dataloader:
                self.assertTupleEqual(d["image"].shape[1:], expected_shape)
    def test_shape(self):
        expected_shape = (128, 128, 128)
        test_image = nib.Nifti1Image(
            np.random.randint(0, 2, size=[128, 128, 128]), np.eye(4))
        test_data = list()
        with tempfile.TemporaryDirectory() as tempdir:
            for i in range(6):
                nib.save(test_image,
                         os.path.join(tempdir, f"test_image{str(i)}.nii.gz"))
                test_data.append({
                    "image":
                    os.path.join(tempdir, f"test_image{str(i)}.nii.gz")
                })

            test_transform = Compose([
                LoadImaged(keys="image"),
                SimulateDelayd(keys="image", delay_time=1e-7),
            ])

            test_stream = _Stream(data=test_data,
                                  dbpath=os.path.join(tempdir, "countDB"))

            dataset = IterableDataset(data=test_stream,
                                      transform=test_transform)
            for d in dataset:
                self.assertTupleEqual(d["image"].shape, expected_shape)

            test_stream.reset()
            dataloader = DataLoader(dataset=dataset,
                                    batch_size=3,
                                    num_workers=2)
            for d in dataloader:
                self.assertTupleEqual(d["image"].shape[1:], expected_shape)
Exemple #4
0
    def setUp(self):
        super().setUp()

        self.datalist = [
            {"image": "spleen_19.nii.gz", "label": "spleen_label_19.nii.gz"},
            {"image": "spleen_31.nii.gz", "label": "spleen_label_31.nii.gz"},
        ]

        self.transform = Compose([SimulateDelayd(keys=["image", "label"], delay_time=0.1)])
    def test_shape(self, expected_shape):
        test_image = nib.Nifti1Image(
            np.random.randint(0, 2, size=[128, 128, 128]), np.eye(4))
        tempdir = tempfile.mkdtemp()
        nib.save(test_image, os.path.join(tempdir, "test_image1.nii.gz"))
        nib.save(test_image, os.path.join(tempdir, "test_label1.nii.gz"))
        nib.save(test_image, os.path.join(tempdir, "test_extra1.nii.gz"))
        nib.save(test_image, os.path.join(tempdir, "test_image2.nii.gz"))
        nib.save(test_image, os.path.join(tempdir, "test_label2.nii.gz"))
        nib.save(test_image, os.path.join(tempdir, "test_extra2.nii.gz"))
        test_data = [
            {
                "image": os.path.join(tempdir, "test_image1.nii.gz"),
                "label": os.path.join(tempdir, "test_label1.nii.gz"),
                "extra": os.path.join(tempdir, "test_extra1.nii.gz"),
            },
            {
                "image": os.path.join(tempdir, "test_image2.nii.gz"),
                "label": os.path.join(tempdir, "test_label2.nii.gz"),
                "extra": os.path.join(tempdir, "test_extra2.nii.gz"),
            },
        ]
        test_transform = Compose([
            LoadNiftid(keys=["image", "label", "extra"]),
            SimulateDelayd(keys=["image", "label", "extra"],
                           delay_time=[1e-7, 1e-6, 1e-5]),
        ])

        dataset_precached = PersistentDataset(data=test_data,
                                              transform=test_transform,
                                              cache_dir=tempdir)
        data1_precached = dataset_precached[0]
        data2_precached = dataset_precached[1]

        dataset_postcached = PersistentDataset(data=test_data,
                                               transform=test_transform,
                                               cache_dir=tempdir)
        data1_postcached = dataset_postcached[0]
        data2_postcached = dataset_postcached[1]
        shutil.rmtree(tempdir)

        self.assertTupleEqual(data1_precached["image"].shape, expected_shape)
        self.assertTupleEqual(data1_precached["label"].shape, expected_shape)
        self.assertTupleEqual(data1_precached["extra"].shape, expected_shape)
        self.assertTupleEqual(data2_precached["image"].shape, expected_shape)
        self.assertTupleEqual(data2_precached["label"].shape, expected_shape)
        self.assertTupleEqual(data2_precached["extra"].shape, expected_shape)

        self.assertTupleEqual(data1_postcached["image"].shape, expected_shape)
        self.assertTupleEqual(data1_postcached["label"].shape, expected_shape)
        self.assertTupleEqual(data1_postcached["extra"].shape, expected_shape)
        self.assertTupleEqual(data2_postcached["image"].shape, expected_shape)
        self.assertTupleEqual(data2_postcached["label"].shape, expected_shape)
        self.assertTupleEqual(data2_postcached["extra"].shape, expected_shape)
Exemple #6
0
    def test_shape(self, expected_shape):
        test_image = nib.Nifti1Image(
            np.random.randint(0, 2, size=[128, 128, 128]), np.eye(4))
        with tempfile.TemporaryDirectory() as tempdir:
            nib.save(test_image, os.path.join(tempdir, "test_image1.nii.gz"))
            nib.save(test_image, os.path.join(tempdir, "test_label1.nii.gz"))
            nib.save(test_image, os.path.join(tempdir, "test_extra1.nii.gz"))
            nib.save(test_image, os.path.join(tempdir, "test_image2.nii.gz"))
            nib.save(test_image, os.path.join(tempdir, "test_label2.nii.gz"))
            nib.save(test_image, os.path.join(tempdir, "test_extra2.nii.gz"))
            test_data = [
                {
                    "image": os.path.join(tempdir, "test_image1.nii.gz"),
                    "label": os.path.join(tempdir, "test_label1.nii.gz"),
                    "extra": os.path.join(tempdir, "test_extra1.nii.gz"),
                },
                {
                    "image": os.path.join(tempdir, "test_image2.nii.gz"),
                    "label": os.path.join(tempdir, "test_label2.nii.gz"),
                    "extra": os.path.join(tempdir, "test_extra2.nii.gz"),
                },
            ]
            test_transform = Compose([
                LoadNiftid(keys=["image", "label", "extra"]),
                SimulateDelayd(keys=["image", "label", "extra"],
                               delay_time=[1e-7, 1e-6, 1e-5]),
            ])
            dataset = Dataset(data=test_data, transform=test_transform)
            data1 = dataset[0]
            data2 = dataset[1]

            self.assertTupleEqual(data1["image"].shape, expected_shape)
            self.assertTupleEqual(data1["label"].shape, expected_shape)
            self.assertTupleEqual(data1["extra"].shape, expected_shape)
            self.assertTupleEqual(data2["image"].shape, expected_shape)
            self.assertTupleEqual(data2["label"].shape, expected_shape)
            self.assertTupleEqual(data2["extra"].shape, expected_shape)

            dataset = Dataset(
                data=test_data,
                transform=LoadNiftid(keys=["image", "label", "extra"]))
            data1_simple = dataset[0]
            data2_simple = dataset[1]

            self.assertTupleEqual(data1_simple["image"].shape, expected_shape)
            self.assertTupleEqual(data1_simple["label"].shape, expected_shape)
            self.assertTupleEqual(data1_simple["extra"].shape, expected_shape)
            self.assertTupleEqual(data2_simple["image"].shape, expected_shape)
            self.assertTupleEqual(data2_simple["label"].shape, expected_shape)
            self.assertTupleEqual(data2_simple["extra"].shape, expected_shape)
Exemple #7
0
    def test_shape(self, expected_shape):
        test_image = nib.Nifti1Image(
            np.random.randint(0, 2, size=[128, 128, 128]), np.eye(4))
        tempdir = tempfile.mkdtemp()
        nib.save(test_image, os.path.join(tempdir, 'test_image1.nii.gz'))
        nib.save(test_image, os.path.join(tempdir, 'test_label1.nii.gz'))
        nib.save(test_image, os.path.join(tempdir, 'test_extra1.nii.gz'))
        nib.save(test_image, os.path.join(tempdir, 'test_image2.nii.gz'))
        nib.save(test_image, os.path.join(tempdir, 'test_label2.nii.gz'))
        nib.save(test_image, os.path.join(tempdir, 'test_extra2.nii.gz'))
        test_data = [{
            'image': os.path.join(tempdir, 'test_image1.nii.gz'),
            'label': os.path.join(tempdir, 'test_label1.nii.gz'),
            'extra': os.path.join(tempdir, 'test_extra1.nii.gz')
        }, {
            'image': os.path.join(tempdir, 'test_image2.nii.gz'),
            'label': os.path.join(tempdir, 'test_label2.nii.gz'),
            'extra': os.path.join(tempdir, 'test_extra2.nii.gz')
        }]
        test_transform = Compose([
            LoadNiftid(keys=['image', 'label', 'extra']),
            SimulateDelayd(keys=['image', 'label', 'extra'],
                           delay_time=[1e-7, 1e-6, 1e-5])
        ])
        dataset = Dataset(data=test_data, transform=test_transform)
        data1 = dataset[0]
        data2 = dataset[1]

        self.assertTupleEqual(data1['image'].shape, expected_shape)
        self.assertTupleEqual(data1['label'].shape, expected_shape)
        self.assertTupleEqual(data1['extra'].shape, expected_shape)
        self.assertTupleEqual(data2['image'].shape, expected_shape)
        self.assertTupleEqual(data2['label'].shape, expected_shape)
        self.assertTupleEqual(data2['extra'].shape, expected_shape)

        dataset = Dataset(
            data=test_data,
            transform=LoadNiftid(keys=['image', 'label', 'extra']))
        data1_simple = dataset[0]
        data2_simple = dataset[1]

        self.assertTupleEqual(data1_simple['image'].shape, expected_shape)
        self.assertTupleEqual(data1_simple['label'].shape, expected_shape)
        self.assertTupleEqual(data1_simple['extra'].shape, expected_shape)
        self.assertTupleEqual(data2_simple['image'].shape, expected_shape)
        self.assertTupleEqual(data2_simple['label'].shape, expected_shape)
        self.assertTupleEqual(data2_simple['extra'].shape, expected_shape)
import os
import tempfile
import unittest

import nibabel as nib
import numpy as np
from parameterized import parameterized

from monai.data import PersistentDataset, json_hashing
from monai.transforms import Compose, LoadImaged, SimulateDelayd, Transform

TEST_CASE_1 = [
    Compose([
        LoadImaged(keys=["image", "label", "extra"]),
        SimulateDelayd(keys=["image", "label", "extra"],
                       delay_time=[1e-7, 1e-6, 1e-5]),
    ]),
    (128, 128, 128),
]

TEST_CASE_2 = [
    [
        LoadImaged(keys=["image", "label", "extra"]),
        SimulateDelayd(keys=["image", "label", "extra"],
                       delay_time=[1e-7, 1e-6, 1e-5]),
    ],
    (128, 128, 128),
]

TEST_CASE_3 = [None, (128, 128, 128)]