Merge pull request #1 from jburel/axes

Axes

Author: dominikl

src/main/java/com/glencoesoftware/omero/zarr/ZarrPixelBuffer.java

@@ -95,7 +95,7 @@ public class ZarrPixelBuffer implements PixelBuffer {
     /** Array path vs. ZarrArray cache */
     private final AsyncLoadingCache<Path, ZarrArray> zarrArrayCache;
 
-    private enum Axes {
+    public enum Axes {
         X, Y, Z, C, T;
     }
 

src/test/java/com/glencoesoftware/omero/zarr/ZarrPixelBufferTest.java

@@ -38,6 +38,7 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import com.glencoesoftware.omero.zarr.ZarrPixelBuffer.Axes;
 
 import com.bc.zarr.ArrayParams;
 import com.bc.zarr.DimensionSeparator;
@@ -186,14 +187,16 @@ static Path fake(Map<String, String> options,
     }
 
     public Path writeTestZarr(
-            int sizeT,
-            int sizeC,
-            int sizeZ,
-            int sizeY,
-            int sizeX,
-            String pixelType,
-            int resolutions) throws IOException {
-        Path input = fake(
+        int sizeT,
+        int sizeC,
+        int sizeZ,
+        int sizeY,
+        int sizeX,
+        String pixelType,
+        int resolutions,
+        String order) throws IOException {
+
+            Path input = fake(
                 "sizeT", Integer.toString(sizeT),
                 "sizeC", Integer.toString(sizeC),
                 "sizeZ", Integer.toString(sizeZ),
@@ -202,99 +205,41 @@ public Path writeTestZarr(
                 "pixelType", pixelType,
                 "resolutions", Integer.toString(resolutions));
         Path output = tmpDir.getRoot().toPath().resolve("output.zarr");
-        assertBioFormats2Raw(input, output);
-        List<Object> msArray = new ArrayList<>();
-        Map<String, Object> msData = new HashMap<>();
-        Map<String, Object> msMetadata = new HashMap<>();
-        msMetadata.put("method", "loci.common.image.SimpleImageScaler");
-        msMetadata.put("version", "Bio-Formats 6.5.1");
-        msData.put("metadata", msMetadata);
-        msData.put("datasets", getDatasets(resolutions));
-        msData.put("version", "0.1");
-        msArray.add(msData);
-        ZarrGroup z = ZarrGroup.open(output.resolve("0"));
-        Map<String,Object> attrs = new HashMap<String, Object>();
-        attrs.put("multiscales", msArray);
-        z.writeAttributes(attrs);
-        return output;
-    }
-
-    public Path writeTestZarrWithAxes(int sizeT,
-    int sizeC,
-    int sizeZ,
-    int sizeY,
-    int sizeX,
-    String order) throws IOException, InvalidRangeException {
-        Path output = tmpDir.getRoot().toPath().resolve("output.zarr");
-        Path series_path = output.resolve("0");
-        Path img_path = series_path.resolve("0");
-        int[] shape = new int[5];
-        shape[order.indexOf("C")] = sizeC;
-        shape[order.indexOf("T")] = sizeT;
-        shape[order.indexOf("Z")] = sizeZ;
-        shape[order.indexOf("Y")] = sizeY;
-        shape[order.indexOf("X")] = sizeX;
-        ZarrArray array = ZarrArray.create(img_path.toString(), new ArrayParams()
-        .shape(shape)
-        .dataType(com.bc.zarr.DataType.i4)
-        .dimensionSeparator(DimensionSeparator.SLASH)
-        );
-
-        for (int i = 0; i < sizeC; i++) {
-            for (int j = 0; j < sizeT; j++) {
-                for (int k = 0; k < sizeZ; k++) {
-                    int[] plane = getRandomPlane(sizeX, sizeY);
-                    int[] sh = new int[5];
-                    int[] off = new int[5];
-                    sh[order.indexOf("C")] = 1;
-                    sh[order.indexOf("T")] = 1;
-                    sh[order.indexOf("Z")] = 1;
-                    sh[order.indexOf("Y")] = sizeY;
-                    sh[order.indexOf("X")] = sizeX;
-                    off[order.indexOf("C")] = i;
-                    off[order.indexOf("T")] = j;
-                    off[order.indexOf("Z")] = k;
-                    off[order.indexOf("Y")] = 0;
-                    off[order.indexOf("X")] = 0;
-                    array.write(plane, sh, off);
-                }
-            }
+        if (order != null) {
+            assertBioFormats2Raw(input, output, "--dimension-order", order);
+        } else {
+            assertBioFormats2Raw(input, output);
         }
-
-        String rootZattrs = "{\n" + //
-                        "  \"bioformats2raw.layout\" : 3\n" + //
-                        "}";
-        String zgroup = "{\n" + //
-                        "  \"zarr_format\" : 2\n" + //
-                        "}";
-        Files.write(output.resolve(".zattrs"), rootZattrs.getBytes());
-        Files.write(output.resolve(".zgroup"), zgroup.getBytes());
-        Files.write(series_path.resolve(".zgroup"), zgroup.getBytes());
-
+        
         List<Object> msArray = new ArrayList<>();
         Map<String, Object> msData = new HashMap<>();
         Map<String, Object> msMetadata = new HashMap<>();
         msMetadata.put("method", "loci.common.image.SimpleImageScaler");
         msMetadata.put("version", "Bio-Formats 6.5.1");
         msData.put("metadata", msMetadata);
-        msData.put("axes", getAxes(order));
-        msData.put("datasets", getDatasets(1));
+        if (order != null) {
+            msData.put("axes", getAxes(new StringBuffer(order).reverse().toString()));
+        }
+        msData.put("datasets", getDatasets(resolutions));
         msData.put("version", "0.1");
         msArray.add(msData);
         ZarrGroup z = ZarrGroup.open(output.resolve("0"));
         Map<String,Object> attrs = new HashMap<String, Object>();
         attrs.put("multiscales", msArray);
         z.writeAttributes(attrs);
-        
         return output;
-    }
-
-    private int[] getRandomPlane(int x, int y) {
-        int[] res = new int[x*y];
-        for (int i = 0; i < res.length; i++) {
-            res[i] = (int) (Math.random() * 255);
+            
         }
-        return res;
+    public Path writeTestZarr(
+            int sizeT,
+            int sizeC,
+            int sizeZ,
+            int sizeY,
+            int sizeX,
+            String pixelType,
+            int resolutions) throws IOException {
+        return writeTestZarr(sizeT, sizeC, sizeZ, sizeY, sizeX, pixelType,
+                resolutions, null);
     }
 
     List<Map<String, String>> getDatasets(int resolutions) {
@@ -907,7 +852,7 @@ public void testDownsampledZ() throws IOException {
     }
 
     @Test
-    public void testAxes()
+    public void testReadDataNonDefaultAxes()
             throws IOException, InvalidRangeException {
         // Pretty much the same as testGetTimepointStackPlaneRowCol()
         // but testing a different axes order.
@@ -916,22 +861,24 @@ public void testAxes()
         int sizeZ = 4;
         int sizeY = 1024;
         int sizeX = 2048;
+        int resolutions = 1;
         String order = DimensionOrder.VALUE_XYCTZ;
         Pixels pixels = new Pixels(
                 null, new PixelsType(PixelsType.VALUE_INT32), 
                 sizeX, sizeY, sizeZ, sizeC, sizeT, "", new DimensionOrder(order));
-        Path output = writeTestZarrWithAxes(sizeT, sizeC, sizeZ, sizeY, sizeX, order);
+        Path output = writeTestZarr(
+            sizeT, sizeC, sizeZ, sizeY, sizeX, "int32", resolutions, order);
+        String reverse_order = new StringBuilder(order).reverse().toString();
         try (ZarrPixelBuffer zpbuf =
                 createPixelBuffer(pixels, output.resolve("0"), sizeX, sizeY)) {
-            System.out.println("pixel type: " + zpbuf.getPixelsType());
             for (int t = 0; t < sizeT; t++) {
                 // Assert timepoint
                 byte[] timepoint = zpbuf.getTimepoint(t).getData().array();
                 for (int c = 0; c < sizeC; c++) {
                     // Assert stack
                     byte[] stack = zpbuf.getStack(c, t).getData().array();
                     byte[] stackFromTimepoint =
-                            getStack(timepoint, c, sizeC, sizeZ, sizeX, sizeY, order);
+                            getStack(timepoint, c, sizeC, sizeZ, sizeX, sizeY, reverse_order);
                     Assert.assertArrayEquals(stack, stackFromTimepoint);
                     for (int z = 0; z < sizeZ; z++) {
                         // Assert plane
@@ -958,4 +905,69 @@ null, new PixelsType(PixelsType.VALUE_INT32),
             }
         }
     }
+
+    @Test
+    public void testNonDefaultAxes()
+        throws IOException, InvalidRangeException {
+        int sizeT = 1;
+        int sizeC = 2;
+        int sizeZ = 16;
+        int sizeY = 256;
+        int sizeX = 256;
+        int resolutions = 1;
+        String order = DimensionOrder.VALUE_XYCTZ;
+        Pixels pixels = new Pixels(
+                null, null, sizeX, sizeY, sizeZ, sizeC, sizeT, "", new DimensionOrder(order));
+        Path output = writeTestZarr(
+                sizeT, sizeC, sizeZ, sizeY, sizeX, "uint8", resolutions, order);
+        try (ZarrPixelBuffer zpbuf =
+                createPixelBuffer(pixels, output.resolve("0"), sizeX, sizeY)) {
+                    Map<Axes, Integer> axes = zpbuf.getAxes();
+                    Assert.assertEquals(0, axes.get(Axes.Z).intValue());
+                    Assert.assertEquals(1, axes.get(Axes.T).intValue());
+                    Assert.assertEquals(2, axes.get(Axes.C).intValue());
+                    Assert.assertEquals(3, axes.get(Axes.Y).intValue());
+                    Assert.assertEquals(4, axes.get(Axes.X).intValue());
+                    Assert.assertEquals(sizeT, zpbuf.getSizeT());
+                    Assert.assertEquals(sizeC, zpbuf.getSizeC());
+                    Assert.assertEquals(sizeZ, zpbuf.getSizeZ());
+                    Assert.assertEquals(sizeY, zpbuf.getSizeY());
+                    Assert.assertEquals(sizeX, zpbuf.getSizeX());
+        }
+    }
+
+    @Test
+    public void testDefaultAxes()
+        throws IOException, InvalidRangeException {
+        // Check that if access are not in the file it defaults to TCZYX order when no axes found
+
+        int sizeT = 1;
+        int sizeC = 2;
+        int sizeZ = 16;
+        int sizeY = 256;
+        int sizeX = 256;
+        int resolutions = 1;
+
+        Pixels pixels = new Pixels(
+                null, null, sizeX, sizeY, sizeZ, sizeC, sizeT, "", null);
+        Path output = writeTestZarr(
+                sizeT, sizeC, sizeZ, sizeY, sizeX, "uint8", resolutions);
+
+        try (ZarrPixelBuffer zpbuf =
+                createPixelBuffer(pixels, output.resolve("0"), sizeX, sizeY)) {
+                    Map<Axes, Integer> axes = zpbuf.getAxes();
+                    Assert.assertEquals(0, axes.get(Axes.T).intValue());
+                    Assert.assertEquals(1, axes.get(Axes.C).intValue());
+                    Assert.assertEquals(2, axes.get(Axes.Z).intValue());
+                    Assert.assertEquals(3, axes.get(Axes.Y).intValue());
+                    Assert.assertEquals(4, axes.get(Axes.X).intValue());
+                    Assert.assertEquals(sizeT, zpbuf.getSizeT());
+                    Assert.assertEquals(sizeC, zpbuf.getSizeC());
+                    Assert.assertEquals(sizeZ, zpbuf.getSizeZ());
+                    Assert.assertEquals(sizeY, zpbuf.getSizeY());
+                    Assert.assertEquals(sizeX, zpbuf.getSizeX());
+        }
+    }
+
+
 }