RandomAffine

[kodohoi]

Hi!

I would like to perform "RandomAffine" augmentation partially. This is because that some head DICOM images which I deal with contain partial deformation caused by fractures.

Are there any good ideas or methods to generate partial deformation artificially?

Thanks in advance.

[fepegar]

Hi, @kodohoi. Can you please elaborate? What do you mean by perform augmentation partially? Can you show some examples and explain more about what you're trying to achieve?

[kodohoi]

@fepegar. Sorry for the lack of explanation.

I usually deal with the head CT of "Bone". However, there are often bone deformations such as a partial dent or distortion caused by fractures, like the below image (DOI‐10.21304/2017.0401.00160).

Therefore, I would like to reproduce those bone deformation as data augmentation.
Although "RandomSwap" might be similar, there are differences, I think...
Because I thought that using "RandomAffine" partially could reproduce a similar situation artificially, I implemented the "RandomAffinepartial" class as below...

class RandomAffinePartial:
    def __init__(self, 
                 degrees=10.0, 
                 translation=5.0, 
                 scales=0.0, 
                 patch_size = (100,100,100), 
                 p=0.5):
        self.degrees = degrees
        self.translation = translation
        self.scales = scales
        self.p = p
        self.patch_size = patch_size
        
    def __call__(self, image):
        if random.random() < self.p:
            # Convert patch_size to numpy array
            patch_size = np.array(self.patch_size)

            # Get the spatial dimensions of the image
            _, si, sj, sk = image.shape

            # Select a random location for the patch
            patch_start = np.array([
                np.random.randint(0, si - patch_size[0] + 1),
                np.random.randint(0, sj - patch_size[1] + 1),
                np.random.randint(0, sk - patch_size[2] + 1)
            ])

            # Extract the patch
            for name, img in image.get_images_dict().items():
                affine = img.affine
                patch = img.data[:,patch_start[0]:patch_start[0] + patch_size[0], 
                                   patch_start[1]:patch_start[1] + patch_size[1], 
                                   patch_start[2]:patch_start[2] + patch_size[2]]
                patch_image = tio.ScalarImage(tensor=patch, affine=affine)

                # Create a random affine transform
                transform = tio.RandomAffine(
                    degrees=self.degrees,
                    translation=self.translation,
                    scales=self.scales
                )

                # Apply the transform to the patch
                transformed_patch = transform(patch_image)

                # Create a new image with the transformed patch at the same location
                transformed_image_data = img.data
                transformed_image_data[:,patch_start[0]:patch_start[0] + patch_size[0], 
                                       patch_start[1]:patch_start[1] + patch_size[1], 
                                       patch_start[2]:patch_start[2] + patch_size[2]] = transformed_patch.data
                transformed_image = tio.ScalarImage(tensor=transformed_image_data, affine=affine)
                image[name] = transformed_image
                
        return image

Are there any good methods to reproduce the bone deformation like above image?
Thanks in advance.

[romainVala]

hi
interesting application. I think your solution make sense.
may be you also want to test Elastic transformation to simulate the local deformation induce by the fracture