Implemented distributed regridding

[philippjfr]

Implements regridding of dask.array.Array backed xarray.DataArray objects without loading the entire array into memory.

The basic idea here is that the operation will no longer load dask arrays into memory, instead it will resample the original data in chunks and then stack the resampled chunks along the two axes. By default it will try to keep the chunksize consistent, however it now also exposes a memory constraint which can be used to limit the amount of data in memory at any one time.

If enabled it is possible to end up with situations where resampling cannot be performed given the memory constraints, e.g. let us say you have a 1 GB array which is roughly 12k x 12k in shape, and we want to resample it into a 10x10 grid. If we we give it a memory limit of 100 KB, even if each output chunk is only 1x1 it still has to load a 1200x1200 grid, i.e. about 11.5 MB, into memory . This could be solved by splitting the task and creating temporary chunks which are then aggregated but I considered that out of scope. Instead you will get an error that you have to relax the memory constraint.

Here is the profiling output when regridding a 10k x 10k grid into a 100x100 grid:

Here is the same, but this time the array isn't already in memory but loaded from disk with zarr:

Here we are zooming on a 50k x 50k (20 GB) array loaded with zarr (note how it slows down when we zoom out), while trying to minimize memory load:

Known issues

• Upsampling with 'linear' interpolation does not yet use correct padding so boundaries are wrong

• Add tests

[jbednar]

Looks great! Please merge once the minor review comments have been addressed and the tests pass. Thanks for doing the clearly somewhat painful work involved in this. I tried my best to focus on some of the hairier C-like code here, and it looks fine, but it would be difficult for me to spot an off-by-one error...