testing rand bias field

Author: wyli

niftynet/layer/rand_bias_field.py

@@ -14,9 +14,9 @@ class RandomBiasFieldLayer(RandomisedLayer):
     def __init__(self, name='random_bias_field'):
         super(RandomBiasFieldLayer, self).__init__(name=name)
         self._bf_coeffs = None
-        self.min_coeff = None
-        self.max_coeff = None
-        self.order = None
+        self.min_coeff = -10.0
+        self.max_coeff = 10.0
+        self.order = 3
 
     def init_uniform_coeff(self, coeff_range=(-10.0, 10.0)):
         assert coeff_range[0] < coeff_range[1]
@@ -30,84 +30,81 @@ def randomise(self, spatial_rank=3):
         self._generate_bias_field_coeffs(spatial_rank)
 
     def _generate_bias_field_coeffs(self, spatial_rank):
-        '''
+        """
         Sampling of the appropriate number of coefficients for the creation
         of the bias field map
         :param spatial_rank: spatial rank of the image to modify
         :return:
-        '''
+        """
         rand_coeffs = []
         if spatial_rank == 3:
-            for order_x in range(0, self.order+1):
-                for order_y in range(0, self.order +1- order_x):
-                    for order_z in range(0, self.order+1 -(order_x + order_y)):
+            for order_x in range(0, self.order + 1):
+                for order_y in range(0, self.order + 1 - order_x):
+                    for order_z in range(0,
+                                         self.order + 1 - (order_x + order_y)):
                         rand_coeff_new = np.random.uniform(self.min_coeff,
-                                                       self.max_coeff)
+                                                           self.max_coeff)
                         rand_coeffs.append(rand_coeff_new)
         else:
-            for order_x in range(0, self.order+1):
-                for order_y in range(0, self.order +1- order_x):
+            for order_x in range(0, self.order + 1):
+                for order_y in range(0, self.order + 1 - order_x):
                     rand_coeff_new = np.random.uniform(self.min_coeff,
                                                        self.max_coeff)
                     rand_coeffs.append(rand_coeff_new)
         self._bf_coeffs = rand_coeffs
 
     def _generate_bias_field_map(self, shape):
-        '''
+        """
         Create the bias field map using a linear combination polynomial
         functions and the coefficients previously sampled
         :param shape: shape of the image in order to create the polynomial
-        functions
+            functions
         :return: bias field map to apply
-        '''
+        """
         spatial_rank = len(shape)
         x_range = np.arange(-shape[0] / 2, shape[0] / 2)
         y_range = np.arange(-shape[1] / 2, shape[1] / 2)
         bf_map = np.zeros(shape)
         i = 0
         if spatial_rank == 3:
             z_range = np.arange(-shape[2] / 2, shape[2] / 2)
-            x_mesh, y_mesh, z_mesh = np.asarray(np.meshgrid(x_range, y_range,
-                                                z_range), dtype=float)
+            x_mesh, y_mesh, z_mesh = np.asarray(
+                np.meshgrid(x_range, y_range, z_range), dtype=float)
             x_mesh /= float(np.max(x_mesh))
             y_mesh /= float(np.max(y_mesh))
             z_mesh /= float(np.max(z_mesh))
-            for order_x in range(0, self.order+1):
-                for order_y in range(0, self.order + 1 - order_x):
-                    for order_z in range(0, self.order + 1 - (order_x+order_y)):
+            for order_x in range(self.order + 1):
+                for order_y in range(self.order + 1 - order_x):
+                    for order_z in range(self.order + 1 - (order_x + order_y)):
                         rand_coeff = self._bf_coeffs[i]
-
-                        new_map = rand_coeff * np.power(x_mesh, order_x) * \
-                            np.power(y_mesh, order_y) * \
-                            np.power(z_mesh, order_z)
-                        # print(np.asarray(np.where(np.abs(new_map) >
-                        #                           0)).shape, np.unique(
-                        #     new_map).shape)
+                        new_map = rand_coeff * \
+                                  np.power(x_mesh, order_x) * \
+                                  np.power(y_mesh, order_y) * \
+                                  np.power(z_mesh, order_z)
                         bf_map += np.transpose(new_map, (1, 0, 2))
                         i += 1
         if spatial_rank == 2:
-            x_mesh, y_mesh = np.asarray(np.meshgrid(x_range, y_range),
-                                        dtype=float)
+            x_mesh, y_mesh = np.asarray(
+                np.meshgrid(x_range, y_range), dtype=float)
             x_mesh /= np.max(x_mesh)
             y_mesh /= np.max(y_mesh)
-            for order_x in range(0, self.order+1):
-                for order_y in range(0, self.order+1 - order_x):
+            for order_x in range(self.order + 1):
+                for order_y in range(self.order + 1 - order_x):
                     rand_coeff = self._bf_coeffs[i]
-                    new_map = rand_coeff * np.power(x_mesh, order_x) * \
-                        np.power(y_mesh, order_y)
+                    new_map = rand_coeff * \
+                              np.power(x_mesh, order_x) * \
+                              np.power(y_mesh, order_y)
                     bf_map += np.transpose(new_map, (1, 0))
                     i += 1
         return np.exp(bf_map)
 
     def _apply_transformation(self, image):
-        '''
+        """
         Create the bias field map based on the randomly sampled coefficients
-        and apply it (
-        multiplicative) to the image
-        to augment
-        :param image image on which to apply the bias field augmentation:
+        and apply it (multiplicative) to the image to augment
+        :param image: image on which to apply the bias field augmentation
         :return: modified image
-        '''
+        """
         assert self._bf_coeffs is not None
         bf_map = self._generate_bias_field_map(image.shape)
         bf_image = image * bf_map
@@ -117,20 +114,15 @@ def layer_op(self, inputs, interp_orders, *args, **kwargs):
         if inputs is None:
             return inputs
         for (field, image) in inputs.items():
-            print(field)
             if field == 'image':
                 for mod_i in range(image.shape[-1]):
                     if image.ndim == 4:
                         inputs[field][..., mod_i] = \
-                            self._apply_transformation(
-                                image[..., mod_i])
+                            self._apply_transformation(image[..., mod_i])
                     elif image.ndim == 5:
                         for t in range(image.shape[-2]):
                             inputs[field][..., t, mod_i] = \
-                                self._apply_transformation(
-                                    image[..., t, mod_i])
+                                self._apply_transformation(image[..., t, mod_i])
                     else:
                         raise NotImplementedError("unknown input format")
         return inputs
-
-

tests/rand_bias_field_test.py

@@ -0,0 +1,78 @@
+from __future__ import absolute_import, print_function
+
+import numpy as np
+import tensorflow as tf
+
+from niftynet.layer.rand_bias_field import RandomBiasFieldLayer
+
+SHAPE_4D = (10, 16, 16, 2)
+SHAPE_5D = (10, 32, 32, 8, 1)
+
+
+class RandDeformationTests(tf.test.TestCase):
+    # def get_3d_input(self):
+    #     input_3d = {'image': np.random.randn(10, 16, 2)}
+    #     interp_order = {'image': (3,) * 2}
+    #     return input_3d, interp_order
+
+    def get_4d_input(self):
+        input_4d = {'image': np.random.randn(*SHAPE_4D)}
+        interp_order = {'image': (3,) * 2}
+        return input_4d, interp_order
+
+    def get_5d_input(self):
+        input_5d = {'image': np.random.randn(*SHAPE_5D)}
+        interp_order = {'image': (3,)}
+        return input_5d, interp_order
+
+    def test_4d_shape(self):
+        x, interp_orders = self.get_4d_input()
+        rand_bias_field_layer = RandomBiasFieldLayer()
+        rand_bias_field_layer.randomise()
+        out = rand_bias_field_layer(x, interp_orders)
+        self.assertEqual(out['image'].shape, SHAPE_4D)
+
+    def test_5d_shape(self):
+        x, interp_orders = self.get_5d_input()
+        rand_bias_field_layer = RandomBiasFieldLayer()
+        rand_bias_field_layer.randomise()
+        out = rand_bias_field_layer(x, interp_orders)
+        self.assertEqual(out['image'].shape, SHAPE_5D)
+
+    def test_augmentation(self):
+        rand_bias_field_layer = RandomBiasFieldLayer()
+        x, interp_orders = self.get_5d_input()
+        x_old = np.copy(x['image'])
+        for _ in range(10):
+            x['image'] = np.copy(x_old)
+
+            rand_bias_field_layer.randomise()
+            out = rand_bias_field_layer(x, interp_orders)
+            out = np.copy(out['image'])
+
+            rand_bias_field_layer.init_order(2)
+            rand_bias_field_layer.init_uniform_coeff((-5.0, 5.0))
+
+            rand_bias_field_layer.randomise()
+            x['image'] = np.copy(x_old)
+            out2 = rand_bias_field_layer(x, interp_orders)
+
+            self.assertFalse(np.array_equal(out, x_old))
+            self.assertFalse(np.array_equal(out2['image'], x_old))
+            self.assertFalse(np.array_equal(out, out2['image']))
+
+    # def test_gugmentation_on_2d_imgs(self):
+    #     rand_bias_field_layer = RandomBiasFieldLayer()
+    #     for _ in range(100):
+    #         x, interp_orders = self.get_3d_input()
+    #         x_old = np.copy(x['image'])
+
+    #         rand_bias_field_layer.randomise(x)
+    #         out = rand_bias_field_layer(x, interp_orders)
+
+    #         with self.test_session():
+    #             self.assertFalse(np.array_equal(out['image'], x_old))
+
+
+if __name__ == "__main__":
+    tf.test.main()

tests/rand_elastic_deformation_test.py

@@ -7,20 +7,25 @@
 from niftynet.layer.rand_elastic_deform import RandomElasticDeformationLayer
 from niftynet.layer.rand_elastic_deform import sitk
 
+SHAPE_3D = (10, 16, 2)
+SHAPE_4D = (10, 16, 16, 2)
+SHAPE_5D = (10, 32, 32, 8, 1)
+
+
 @unittest.skipIf(not sitk, 'SimpleITK not found')
 class RandDeformationTests(tf.test.TestCase):
     def get_3d_input(self):
-        input_3d = {'testdata': np.random.randn(10, 16, 2)}
+        input_3d = {'testdata': np.random.randn(*SHAPE_3D)}
         interp_order = {'testdata': (3,) * 2}
         return input_3d, interp_order
 
     def get_4d_input(self):
-        input_4d = {'testdata': np.random.randn(10, 16, 16, 2)}
+        input_4d = {'testdata': np.random.randn(*SHAPE_4D)}
         interp_order = {'testdata': (3,) * 2}
         return input_4d, interp_order
 
     def get_5d_input(self):
-        input_5d = {'testdata': np.random.randn(10, 32, 32, 8, 1)}
+        input_5d = {'testdata': np.random.randn(*SHAPE_5D)}
         interp_order = {'testdata': (3,)}
         return input_5d, interp_order
 
@@ -31,6 +36,7 @@ def test_4d_shape(self):
                                                                proportion_to_augment=0.5)
         rand_deformation_layer.randomise(x)
         out = rand_deformation_layer(x, interp_orders)
+        self.assertEqual(out['testdata'].shape, SHAPE_4D)
 
     def test_5d_shape(self):
         x, interp_orders = self.get_5d_input()
@@ -39,6 +45,7 @@ def test_5d_shape(self):
                                                                proportion_to_augment=0.5)
         rand_deformation_layer.randomise(x)
         out = rand_deformation_layer(x, interp_orders)
+        self.assertEqual(out['testdata'].shape, SHAPE_5D)
 
     def test_no_deformation(self):
         # testing the 'proportion_to_augment' parameter