downscale_local_mean with non-integer factors?

[shoyer]

I'm interested in a version of skimage.transform.downscale_local_mean() which handles non-evenly dividing factors without padding the image. I want each pixel in the result to be an weighted average of overlapping pixels in the source, with weights equal to the area of overlap.

To be more explicit, this transformation is linear along equal axis. For example, from size 5 to size 2, it can be written as the matrix:

[[0.4, 0.4, 0.2, 0.0, 0.0],
 [0.0, 0.0, 0.2, 0.4, 0.4]]

This is actually what I expected skimage.transform.resize() to do, before I noticed the docstring warning about anti-aliasing.

Would this be a welcome addition to scikit-image in some form? I wrote a version that works for my own purposes, but my guess is that it's too slow for skimage, since I use a dense matrix multiply along each axis with matrix of weights.

[ahojnnes]

Hi, thanks for reaching out. Even if your implementation is slow, this would be a useful option. I would integrate it into the existing downscale_local_mean function as another option. Does your implementation generalize to N-D?

[shoyer]

Does your implementation generalize to N-D?

Yes, it works in N dimensions. It's written as a sequence of matrix multiplications, one along each axis.

[ahojnnes]

Sounds great, looking forward to a pull request with the feature!

[stefanv]

This has actually been requested before, so thanks for contributing!

[shoyer]

Do you have any guidance on the appropriate API here?

This breaks at least two aspects of the API for downscale_local_mean:

• factors don't need to be integers.
• cval doesn't make sense.

Also, we can just as easily do upscaling with the local mean value as well downscaling, e.g., resizing [0, 1] to size 5 would result in [0, 0, 0.5, 1, 1].

My initial thought was to make cval=None an indicator to do resizing with fractional overlap. But then there's the separate issue of non-integer factors. An API that allows non-integer factors only if cval is None seems very awkward. I don't like the value dependent semantics. I suppose we could probably support cval when padding by a fractional factors, but the implementation is not obvious to me and that's not a feature I'm excited to write.

My tentative proposal would be a new function, perhaps resize_local_mean(image, output_shape).

[ahojnnes]

A new function resize_local_mean (maybe rather rescale_local_mean to match the semantics of the existing resize/rescale functions) sounds like a good proposal to me. Potentially, we want to deprecate the old function and merge it into this new function. For this we would probably have to introduce some parameter, eg mode=“cut|pad” and the cval parameter for the pad mode. What do you think? Let’s hear some feedback on that from other people as well. Whenever the input is exactly divisible by integer factors, we could internally also fall back to the old implementation, assuming it was significantly faster?

[stefanv]

I think the old behavior is somewhat broken. We should definitely transition to @shoyer's implementation eventually.

Suggested route: set cval=None for the next two releases, and warn if it is not set to zero explicitly. Then, replace that function with the one proposed.

For now, let's include the function in skimage.future, with an entry in TODO.txt to move it over after the deprecation.

See also http://scikit-image.org/docs/dev/contribute.html#deprecation-cycle

[mchamberland]

@shoyer Would you mind sharing your current implementation? I'm having trouble deriving an analytical expression for the weights of each voxel.

[shoyer]

See https://gist.github.com/shoyer/c0f1ddf409667650a076c058f9a17276 for the version I wrote for my needs.

[mchamberland]

@shoyer Thanks a lot!