Reduce code duplication -- Random dictionary transforms that can't call their array version

[rijobro]

We have both array and dictionary transforms. In a lot of cases, our dictionary transforms include a for loop that repeatedly call the matching array transform. However, because most random array transforms have something like this:

def __call__(self, data):
    self.randomize()
    # do something

We can't call them from the dictionary transform, because doing so would mean that each of the keys of the dictionary would have a different randomisation applied to them. An example of this is RandGaussianNoised, which doesn't call RandGaussianNoise.

We could avoid code duplication by having a boolean as to whether to randomise the data or not. It could look like this:

def __call__(self, data, randomize=True):
    if randomize:
        self.randomize()
    # do something

Then from the dictionary transform, we could call the randomise at the start:

def __init__(self,...):
    self.transform = RandGaussianNoise(...)

def __call__(self, data):
    d = dict(data)
    self.transform.randomize()
    for key in self.key_iterator(d):
        d[key] = self.transform(d[key], randomize=False)

[Nic-Ma]

Hi @rijobro ,

Thanks for raising this topic.
I think we should keep the call() clear and simple, so my proposal would to put the computation logic of array transform to a separate function to avoid calling "call()" in the dict transform. Something like:

class GaussianNoise:
    def randomize(...):
        ...

    def compute(img):
        ...

    def __call__(img):
        self.randomize()
        return self.compute(img)


class GaussianNoised:
    def __init__(self,...):
        self.transform = RandGaussianNoise(...)
    
    def __call__(self, data):
        d = dict(data)
        self.transform.randomize()
        for key in self.key_iterator(d):
            d[key] = self.transform.compute(d[key])

What do you think?
I can think deeper and update some transforms as examples tomorrow.

Thanks.