示例#1
0
    def test_relative_scaling(self):
        img = self.imt
        data = {}
        data["img"] = img
        lower = 10
        upper = 99
        b_min = 100
        b_max = 300
        scaler = ScaleIntensityRangePercentilesd(keys=data.keys(),
                                                 lower=lower,
                                                 upper=upper,
                                                 b_min=b_min,
                                                 b_max=b_max,
                                                 relative=True)

        expected_a_min = np.percentile(img, lower)
        expected_a_max = np.percentile(img, upper)
        expected_b_min = ((b_max - b_min) * (lower / 100.0)) + b_min
        expected_b_max = ((b_max - b_min) * (upper / 100.0)) + b_min
        expected_img = (img - expected_a_min) / (expected_a_max -
                                                 expected_a_min)
        expected_img = (expected_img *
                        (expected_b_max - expected_b_min)) + expected_b_min

        np.testing.assert_allclose(expected_img, scaler(data)["img"])
    def test_scaling(self):
        img = self.imt
        data = {}
        data["img"] = img
        lower = 10
        upper = 99
        b_min = 0
        b_max = 255

        a_min = np.percentile(img, lower)
        a_max = np.percentile(img, upper)
        expected = (img - a_min) / (a_max - a_min)
        expected = (expected * (b_max - b_min)) + b_min

        scaler = ScaleIntensityRangePercentilesd(keys=data.keys(), lower=lower, upper=upper, b_min=b_min, b_max=b_max)

        self.assertTrue(np.allclose(expected, scaler(data)["img"]))
示例#3
0
    def test_scaling(self):
        img = self.imt
        lower = 10
        upper = 99
        b_min = 0
        b_max = 255

        a_min = np.percentile(img, lower)
        a_max = np.percentile(img, upper)
        expected = (((img - a_min) / (a_max - a_min)) * (b_max - b_min) +
                    b_min).astype(np.uint8)

        for p in TEST_NDARRAYS:
            data = {"img": p(img)}
            scaler = ScaleIntensityRangePercentilesd(keys=data.keys(),
                                                     lower=lower,
                                                     upper=upper,
                                                     b_min=b_min,
                                                     b_max=b_max,
                                                     dtype=np.uint8)
            assert_allclose(p(expected), scaler(data)["img"], rtol=1e-4)
示例#4
0
 def test_invalid_instantiation(self):
     self.assertRaises(ValueError,
                       ScaleIntensityRangePercentilesd,
                       keys=["img"],
                       lower=-1,
                       upper=99,
                       b_min=0,
                       b_max=255)
     self.assertRaises(ValueError,
                       ScaleIntensityRangePercentilesd,
                       keys=["img"],
                       lower=101,
                       upper=99,
                       b_min=0,
                       b_max=255)
     self.assertRaises(ValueError,
                       ScaleIntensityRangePercentilesd,
                       keys=["img"],
                       lower=30,
                       upper=-2,
                       b_min=0,
                       b_max=255)
     self.assertRaises(ValueError,
                       ScaleIntensityRangePercentilesd,
                       keys=["img"],
                       lower=30,
                       upper=1000,
                       b_min=0,
                       b_max=255)
     with self.assertRaises(ValueError):
         s = ScaleIntensityRangePercentilesd(keys=["img"],
                                             lower=30,
                                             upper=90,
                                             b_min=None,
                                             b_max=20,
                                             relative=True)
         s(self.imt)
示例#5
0
    def test_channel_wise(self):
        img = np.tile(self.imt, (3, 1, 1, 1))
        lower = 10
        upper = 99
        b_min = 0
        b_max = 255
        scaler = ScaleIntensityRangePercentilesd(keys="img",
                                                 lower=lower,
                                                 upper=upper,
                                                 b_min=b_min,
                                                 b_max=b_max,
                                                 channel_wise=True,
                                                 dtype=np.uint8)
        expected = []
        for c in img:
            a_min = np.percentile(c, lower)
            a_max = np.percentile(c, upper)
            expected.append((((c - a_min) / (a_max - a_min)) *
                             (b_max - b_min) + b_min).astype(np.uint8))
        expected = np.stack(expected)

        for p in TEST_NDARRAYS:
            data = {"img": p(img)}
            assert_allclose(scaler(data)["img"], p(expected), rtol=1e-4)