fix for negative offsets

Author: d-v-b

src/xarray_multiscale/multiscale.py

@@ -291,7 +291,8 @@ def downscale(
             new_coords = tuple(
                 DataArray(
                     (offset * abs(base_coords[bc][1] - base_coords[bc][0]))
-                    + (base_coords[bc][:s] * sc),
+                    + (base_coords[bc][:s] * sc)
+                    - base_coords[bc][0],
                     name=base_coords[bc].name,
                     attrs=base_coords[bc].attrs,
                 )

tests/test_multiscale.py

@@ -1,4 +1,5 @@
 import pytest
+from xarray.core import dataarray
 from xarray_multiscale.multiscale import (
     downscale,
     prepad,
@@ -9,6 +10,7 @@
 import dask.array as da
 import numpy as np
 from xarray import DataArray
+from xarray.testing import assert_equal
 
 
 def test_downscale_depth():
@@ -23,11 +25,13 @@ def test_downscale_depth():
     assert get_downscale_depth((7, 3, 3), (2, 2, 2), pad=True) == 2
     assert get_downscale_depth((1500, 5495, 5200), (2, 2, 2)) == 10
 
-@pytest.mark.parametrize(("size","scale"), ((10,2), (11,2), (12,2), (13,2)))
+
+@pytest.mark.parametrize(("size", "scale"), ((10, 2), (11, 2), (12, 2), (13, 2)))
 def test_even_padding(size: int, scale: int) -> None:
     assert (size + even_padding(size, scale)) % scale == 0
 
-@pytest.mark.parametrize('dim', (1,2,3,4))
+
+@pytest.mark.parametrize("dim", (1, 2, 3, 4))
 def test_prepad(dim: int) -> None:
     size = (10,) * dim
     chunks = (9,) * dim
@@ -53,17 +57,14 @@ def test_downscale_2d():
     arr_dask = da.from_array(arr_numpy, chunks=chunks)
     arr_xarray = DataArray(arr_dask)
 
-    downscaled_numpy_float = downscale(
-        arr_numpy, np.mean, scale).compute()
+    downscaled_numpy_float = downscale(arr_numpy, np.mean, scale).compute()
 
-    downscaled_dask_float = downscale(
-        arr_dask, np.mean, scale).compute()
+    downscaled_dask_float = downscale(arr_dask, np.mean, scale).compute()
 
-    downscaled_xarray_float = downscale(
-        arr_xarray, np.mean, scale).compute()
+    downscaled_xarray_float = downscale(arr_xarray, np.mean, scale).compute()
 
     answer_float = np.array([[0.5, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5]])
-    
+
     assert np.array_equal(downscaled_numpy_float, answer_float)
     assert np.array_equal(downscaled_dask_float, answer_float)
     assert np.array_equal(downscaled_xarray_float, answer_float)
@@ -77,28 +78,52 @@ def test_multiscale():
     cell = np.zeros(np.prod(chunks)).astype("float")
     cell[0] = 1
     cell = cell.reshape(*chunks)
-    array = np.tile(cell, np.ceil(np.divide(shape, chunks)).astype("int"))[cropslice]
-
-    pyr_trimmed = multiscale(array, np.mean, 2, pad_mode=None)
-    pyr_padded = multiscale(array, np.mean, 2, pad_mode="reflect")
-    pyr_trimmed_unchained = multiscale(array, np.mean, 2, pad_mode=None, chained=False)
+    base_array = np.tile(cell, np.ceil(np.divide(shape, chunks)).astype("int"))[
+        cropslice
+    ]
+    pyr_trimmed = multiscale(base_array, np.mean, 2, pad_mode=None)
+    pyr_padded = multiscale(base_array, np.mean, 2, pad_mode="reflect")
+    pyr_trimmed_unchained = multiscale(
+        base_array, np.mean, 2, pad_mode=None, chained=False
+    )
     assert [p.shape for p in pyr_padded] == [
         shape,
         (5, 5, 5),
         (3, 3, 3),
         (2, 2, 2),
         (1, 1, 1),
     ]
-    assert [p.shape for p in pyr_trimmed] == [shape, (4, 4, 4), (2, 2, 2), (1,1,1)]
+    assert [p.shape for p in pyr_trimmed] == [shape, (4, 4, 4), (2, 2, 2), (1, 1, 1)]
 
     # check that the first multiscale array is identical to the input data
-    assert np.array_equal(pyr_padded[0].data.compute(), array)
-    assert np.array_equal(pyr_trimmed[0].data.compute(), array)
+    assert np.array_equal(pyr_padded[0].data.compute(), base_array)
+    assert np.array_equal(pyr_trimmed[0].data.compute(), base_array)
 
     assert np.array_equal(
         pyr_trimmed[-2].data.mean().compute(), pyr_trimmed[-1].data.compute().mean()
     )
     assert np.array_equal(
-        pyr_trimmed_unchained[-2].data.mean().compute(), pyr_trimmed_unchained[-1].data.compute().mean()
+        pyr_trimmed_unchained[-2].data.mean().compute(),
+        pyr_trimmed_unchained[-1].data.compute().mean(),
     )
     assert np.allclose(pyr_padded[0].data.mean().compute(), 0.17146776406035666)
+
+
+def test_coords():
+    dims = ("z", "y", "x")
+    shape = (16,) * len(dims)
+    base_array = np.random.randint(0, 255, shape, dtype="uint8")
+
+    translates = (0.0, -10, 10)
+    scales = (1.0, 2.0, 3.0)
+    coords = tuple(
+        (d, sc * (np.arange(shp) + tr))
+        for d, sc, shp, tr in zip(dims, scales, base_array.shape, translates)
+    )
+    dataarray = DataArray(base_array, coords=coords)
+    downscaled = dataarray.coarsen({"z": 2, "y": 2, "x": 2}).mean()
+
+    multi = multiscale(dataarray, np.mean, (2, 2, 2), preserve_dtype=False)
+
+    assert_equal(multi[0], dataarray)
+    assert_equal(multi[1], downscaled)