Accessing and loading images from Sources

[chris-langfield]

Figured since this is an important topic we could move the discussion from #619 here.

see also #524

Where we're at so far:

#619 (comment)

After discussion earlier, we decided on the following API

src.images[0:5:2]

src.projections[...]

etc

Here is a proof of concept of accomplishing this using a helper class and slices

import numpy as np

class ImageViewHelper:
    
    def __init__(self, fun):
        self.fun = fun
        
    def __getitem__(self, s):
        return self.fun(np.arange(s.start, s.stop, s.step))

class Source:
    
    def __init__(self):
        self.images = ImageViewHelper(self._images)
        
    def _images(self):
        raise AttributeError("Subclass must implement")

class ImageSource(Source):
    
    def __init__(self, data):
        self.data = data
        super().__init__()
        
    def _images(self, indices):
        return data[indices]

data = np.array([np.ones((2,2))*i for i in range(100)])
src = ImageSource(data)
src.images[0:9:2]

What remains is to try to layer this on some of the new work done in this PR (particularly allowing nonsequential/arbitrary indices)

#619 (comment)

Why not just self.fun[s]?

Then I think if .fun was an array, it would already have the indexing behavior we want.... both slices and lists of indices.

#619 (comment)

Why not just self.fun[s]?

Then I think if .fun was an array, it would already have the indexing behavior we want.... both slices and lists of indices.

The only problem I see with this is that it would require loading in all of the images when the ImageViewHelper is instantiated. We want to defer the loading to when _images is called given certain indices, since different sources may have different behaviors.

This way we just convert the slice to the arange of indices and pass it to the private method without having to worry about what it does with them

#619 (comment)

Hey Chris. Sorry, I wasn't implying to load all the images... I was assuming all that was hidden.... I was using fun being an array as an example for conversation. I was being lazy, sorry about that. Anyway, generally when you use slice, the purpose is to avoid actually making/passing ranges around.... we could already do that...

Also I think if the @Property trick works you should not need some extra layers of functions... the .images would take argument, do any clever stuff it needs to do for the slice/indices/(batch?) and call for the specific images in the optimal way. This property trick was the reason to make the helper class as far as I was concerned...

I guess what I am thinking is that .images should 1) take a slice or index iterable thing (arbitray list) 2) be an actual function that finds the optimal way to call for the requested images... Whether we need _images at all is unclear to me, but if we do, it should be simple and without much (any?) indexing logic.

This would also be a time to consider if we want to actually make an iterator (yield etc), or if we plan to continue down the road of manually writing batching code over and over again.

Summarily, I am trying to say that the different logical bits should be isolated, not spread across multiple layers of code. Overall, looks like we still have lots to talk about on this topic but making progress.

[garrettwrong]

Nice, good idea, I forgot about this area already :). Thanks!

Re-reading my short story, I meant generator instead of iterator. If you're not too busy after 2pm and still in the mood we could have a zoom about the state of the branch and maybe breaking this up.

[chris-langfield]

Sure that works! I have an open schedule

[chris-langfield]

From what I can tell (and my attempts) I don't there's a way to have this API without a helper class to have the __getitem__ defined. Can't seem to give a property this functionality by itself, but we modify the main class in the following way so it is at least a property:

class Source:
    
    def __init__(self):
        self.__imageViewHelper = ImageViewHelper(self._images)
        
    @property
    def images(self):
        return self.__imageViewHelper
        
    def _images(self):
        raise AttributeError("Subclass must implement")

See https://stackoverflow.com/questions/57468622/defining-getitem-and-setitem-for-a-property-in-python

[garrettwrong]

Right, sounds good. I think that was what we determined on Friday.