test and fix IndexingUtils.computeProjection

Author: brokkoli71

src/main/java/dev/zarr/zarrjava/utils/IndexingUtils.java

@@ -87,7 +87,7 @@ public static ChunkProjection computeProjection(
 
             if (selOffset[dimIdx] + selShape[dimIdx] > dimLimit) {
                 // selection ends after current chunk
-                shape[dimIdx] = (int) (chunkShape[dimIdx] - (selOffset[dimIdx] % chunkShape[dimIdx]));
+                shape[dimIdx] = (int) (chunkShape[dimIdx] - chunkOffset[dimIdx]);
             } else {
                 // selection ends within current chunk
                 shape[dimIdx] = (int) (selOffset[dimIdx] + selShape[dimIdx] - dimOffset
@@ -187,5 +187,15 @@ public ChunkProjection(
             this.outOffset = outOffset;
             this.shape = shape;
         }
+
+        @Override
+        public String toString() {
+            return "ChunkProjection{" +
+                    "chunkCoords=" + Arrays.toString(chunkCoords) +
+                    ", chunkOffset=" + Arrays.toString(chunkOffset) +
+                    ", outOffset=" + Arrays.toString(outOffset) +
+                    ", shape=" + Arrays.toString(shape) +
+                    '}';
+        }
     }
 }

src/test/java/dev/zarr/zarrjava/TestUtils.java

@@ -1,11 +1,13 @@
 package dev.zarr.zarrjava;
 
 
+import dev.zarr.zarrjava.utils.IndexingUtils;
 import org.junit.Test;
 import org.junit.jupiter.api.Assertions;
 
 import java.util.Arrays;
 
+import static dev.zarr.zarrjava.utils.IndexingUtils.computeChunkCoords;
 import static dev.zarr.zarrjava.utils.Utils.inversePermutation;
 import static dev.zarr.zarrjava.utils.Utils.isPermutation;
 
@@ -27,5 +29,52 @@ public void testInversePermutation() {
         Assertions.assertFalse(Arrays.equals(new int[]{2, 0, 1}, inversePermutation(new int[]{2, 0, 1})));
     }
 
+    @Test
+    public void testComputeChunkCoords(){
+        long[] arrayShape = new long[]{100, 100};
+        int[] chunkShape = new int[]{30, 30};
+        long[] selOffset = new long[]{50, 20};
+        int[] selShape = new int[]{20, 1};
+        long[][] chunkCoords = computeChunkCoords(arrayShape, chunkShape, selOffset, selShape);
+        long[][] expectedChunkCoords = new long[][]{
+                {1, 0},
+                {2, 0},
+        };
+        Assertions.assertArrayEquals(expectedChunkCoords, chunkCoords);
+
+        arrayShape = new long[]{1, 52};
+        chunkShape = new int[]{1, 17};
+        selOffset = new long[]{0, 32};
+        selShape = new int[]{1, 20};
+        chunkCoords = computeChunkCoords(arrayShape, chunkShape, selOffset, selShape);
+        expectedChunkCoords = new long[][]{
+                {0, 1},
+                {0, 2},
+                {0, 3},
+        };
+        Assertions.assertArrayEquals(expectedChunkCoords, chunkCoords);
+    }
+
+    @Test
+    public void testComputeProjection(){
+        // chunk (0,2) contains indexes 34-50 along axis 1
+        // thus the overlap with selection 32-52 is 34-50
+        // which is offset 2 in the selection and offset 0 in the chunk
+        // and has full chunk length 17
+        final long[] chunkCoords = new long[]{0, 2};
+        final long[] arrayShape = new long[]{1, 52};
+        final int[] chunkShape = new int[]{1, 17};
+        final long[] selOffset = new long[]{0, 32};
+        final int[] selShape = new int[]{1, 20};
+
+        IndexingUtils.ChunkProjection projection = IndexingUtils.computeProjection(
+                chunkCoords, arrayShape, chunkShape, selOffset, selShape
+        );
+        Assertions.assertArrayEquals(chunkCoords, projection.chunkCoords);
+        Assertions.assertArrayEquals(new int[]{0,0}, projection.chunkOffset);
+        Assertions.assertArrayEquals(new int[]{0,2}, projection.outOffset);
+        Assertions.assertArrayEquals(new int[]{1, 17}, projection.shape);
+    }
+
 }
 

src/test/java/dev/zarr/zarrjava/ZarrV3Test.java

@@ -26,6 +26,7 @@
 
 import java.io.BufferedReader;
 import java.io.IOException;
+import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
@@ -735,4 +736,41 @@ public void testGroupAttributes() throws IOException, ZarrException {
         group = Group.open(storeHandle);
         Assertions.assertEquals("group_value", group.metadata().attributes().getString("group_attr"));
     }
-}
+
+    @Test
+    public void testTemp() throws ZarrException, IOException {
+        String filePath = TESTOUTPUT + "/testTempV3.txt";
+        int imageWidth = 52;
+        int imageHeight = 1;
+        int chunkWidth = 17;
+        Array input = Array.create(
+                new FilesystemStore(filePath).resolve("0"),
+                Array.metadataBuilder()
+                        .withShape(imageHeight, imageWidth)
+                        .withDataType(DataType.UINT8)
+                        .withChunkShape(imageHeight, chunkWidth)
+                        .withFillValue(0)
+                        .build()
+        );
+
+        byte[] buf = new byte[imageWidth];
+        for (int i = 0; i < buf.length; i++) {
+            buf[i] = (byte) i;
+        }
+        ByteBuffer bytes = ByteBuffer.wrap(buf);
+        ucar.ma2.Array data = ucar.ma2.Array.factory(ucar.ma2.DataType.BYTE, new int[]{imageHeight, imageWidth}, bytes);
+        input.write(new long[]{0, 0}, data);
+
+        long[] readPosition = new long[]{0, 0};
+        int[] readSize = new int[]{1, 32};
+        for (int tile = 0; tile < buf.length; tile += readSize[1]) {
+            readPosition[1] = tile;
+            readSize[1] = (int) Math.min(readSize[1], buf.length - readPosition[1]);
+            ucar.ma2.Array readTile = input.read(readPosition, readSize);
+            for (int i = 0; i < readSize[1]; i++) {
+                byte pixel = readTile.getByte(i);
+                Assertions.assertEquals(buf[tile + i], pixel);
+            }
+        }
+    }
+}