@Override public int getSizeZ() { return reader.getSizeZ(); }
public int getSizeZ() { return reader.getSizeZ(); }
@Override public int getSizeZ() { return reader.getSizeZ(); }
@Override public int getSizeZ() { return getReader().getSizeZ(); }
@Override public int getSizeZ() { return getReader().getSizeZ(); }
/** Helper utility for constructing lengths array, used by main. */ private static final int[] getLengths(IFormatReader r) { return new int[] {r.getSizeZ(), r.getSizeC(), r.getSizeT()}; }
/** Helper utility for constructing lengths array, used by main. */ private static final int[] getLengths(IFormatReader r) { return new int[] {r.getSizeZ(), r.getSizeC(), r.getSizeT()}; }
@Override public int getSizeZ() { FormatTools.assertId(getCurrentFile(), true, 2); return noStitch ? reader.getSizeZ() : core.get(getCoreIndex()).sizeZ; }
@Override public int getSizeZ() { FormatTools.assertId(getCurrentFile(), true, 2); return noStitch ? reader.getSizeZ() : core.get(getCoreIndex()).sizeZ; }
/** * Gets the Z, C and T coordinates corresponding * to the given rasterized index value (real sizes). */ public static int[] getZCTCoords(IFormatReader reader, int index) { String order = reader.getDimensionOrder(); int zSize = reader.getSizeZ(); int cSize = reader.getEffectiveSizeC(); int tSize = reader.getSizeT(); int num = reader.getImageCount(); return getZCTCoords(order, zSize, cSize, tSize, num, index); }
/** * Gets the rasterized index corresponding * to the given Z, C and T coordinates (real sizes). */ public static int getIndex(IFormatReader reader, int z, int c, int t) { String order = reader.getDimensionOrder(); int zSize = reader.getSizeZ(); int cSize = reader.getEffectiveSizeC(); int tSize = reader.getSizeT(); int num = reader.getImageCount(); return getIndex(order, zSize, cSize, tSize, num, z, c, t); }
/** * Gets the Z, C and T coordinates corresponding * to the given rasterized index value (real sizes). */ public static int[] getZCTCoords(IFormatReader reader, int index) { String order = reader.getDimensionOrder(); int zSize = reader.getSizeZ(); int cSize = reader.getEffectiveSizeC(); int tSize = reader.getSizeT(); int num = reader.getImageCount(); return getZCTCoords(order, zSize, cSize, tSize, num, index); }
/** * Gets the rasterized index corresponding * to the given Z, C and T coordinates (real sizes). */ public static int getIndex(IFormatReader reader, int z, int c, int t) { String order = reader.getDimensionOrder(); int zSize = reader.getSizeZ(); int cSize = reader.getEffectiveSizeC(); int tSize = reader.getSizeT(); int num = reader.getImageCount(); return getIndex(order, zSize, cSize, tSize, num, z, c, t); }
/** * Converts index from the given dimension order to the reader's native one. * This method is useful for shuffling the planar order around * (rather than eassigning ZCT sizes as {@link DimensionSwapper} does). * * @throws FormatException Never actually thrown. */ public static int getReorderedIndex(IFormatReader reader, String newOrder, int newIndex) throws FormatException { String origOrder = reader.getDimensionOrder(); int zSize = reader.getSizeZ(); int cSize = reader.getEffectiveSizeC(); int tSize = reader.getSizeT(); int num = reader.getImageCount(); return getReorderedIndex(origOrder, newOrder, zSize, cSize, tSize, num, newIndex); }
public static long getMaxNonzero(IFormatReader reader) { final int siz = reader.getBitsPerPixel() / 8 * reader.getRGBChannelCount() * reader.getSizeX() * reader.getSizeY(); final byte[] buffer = new byte[siz]; final int nC = reader.getSizeC() == reader.getRGBChannelCount() ? 1 : reader.getSizeC(); final int nT = reader.getSizeT(); int z = reader.getSizeZ() - 1; for (;z>=0;z--) for (int c = 0; c < nC; c++ ) for (int t = 0; t < nT; t++) { try { reader.openBytes( reader.getIndex( z, c, t ), buffer ); } catch ( FormatException | IOException e ) { e.printStackTrace(); } if (isNonzero( buffer )) return z; } return 0l; }
private void assertSeries(int series) { reader.setSeries(series); sizeX = reader.getSizeX(); sizeY = reader.getSizeY(); sizeZ = reader.getSizeZ(); sizeC = reader.getSizeC(); sizeT = reader.getSizeT(); imageCount = reader.getImageCount(); bpp = FormatTools.getBytesPerPixel(reader.getPixelType()); planeSize = sizeX * sizeY * bpp; topHalfSize = (sizeY / 2) * sizeX * bpp; bottomHalfSize = (sizeY - (sizeY / 2)) * sizeX * bpp; topLeftQuarterSize = (sizeY / 2) * (sizeX / 2) * bpp; topRightQuarterSize = (sizeY / 2) * (sizeX - (sizeX / 2)) * bpp; bottomLeftQuarterSize = (sizeY - (sizeY / 2)) * (sizeX / 2) * bpp; bottomRightQuarterSize = (sizeY - (sizeY / 2)) * (sizeX - (sizeX / 2)) * bpp; if (!bigImage) { bigImage = sizeX * sizeY > 9000000; } }
@Test public void setId() throws Exception { srcReader = new ImageReader(); checkReader = new ImageReader(); srcReader.setId(src); checkReader.setId(check); assertEquals(srcReader.getSeriesCount(), checkReader.getSeriesCount()); for (int s=0; s<srcReader.getSeriesCount(); s++) { srcReader.setSeries(s); checkReader.setSeries(s); assertEquals(srcReader.getSizeX(), checkReader.getSizeX()); assertEquals(srcReader.getSizeY(), checkReader.getSizeY()); assertEquals(srcReader.getSizeC(), checkReader.getSizeC()); assertEquals(srcReader.getSizeZ(), checkReader.getSizeZ()); assertEquals(srcReader.getSizeT(), checkReader.getSizeT()); assertEquals(srcReader.getPixelType(), checkReader.getPixelType()); assertEquals(srcReader.isRGB(), checkReader.isRGB()); assertEquals(srcReader.getDimensionOrder(), checkReader.getDimensionOrder()); // it's OK if the endian setting is different, so don't check that } }
@Test public void testSinglePyramidMultiplePlanes() throws FormatException, IOException { writePyramid(files[5].getAbsolutePath(), new int[] {16}, new int[] {16}, 3, 0, false, true); IFormatReader reader = getReader(5); try { assertEquals(reader.getSeriesCount(), 1); assertEquals(reader.getResolutionCount(), RESOLUTION_COUNT); assertEquals(reader.getSizeX(), 16); assertEquals(reader.getSizeY(), 16); for (int i=0; i<RESOLUTION_COUNT; i++) { reader.setResolution(i); assertEquals(reader.getSizeZ(), 3); } assertTrue(checkPixels(reader)); } finally { reader.close(); } }
@Test public void testMultiplePyramidsMultiplePlanes() throws FormatException, IOException { int[] dims = new int[] {8, 10}; writePyramid(files[8].getAbsolutePath(), dims, dims, 2, 0, false, true); IFormatReader reader = getReader(8); try { assertEquals(reader.getSeriesCount(), 2); for (int s=0; s<reader.getSeriesCount(); s++) { reader.setSeries(s); assertEquals(reader.getResolutionCount(), RESOLUTION_COUNT); assertEquals(reader.getSizeX(), dims[s]); assertEquals(reader.getSizeY(), dims[s]); assertEquals(reader.getSizeZ(), 2); } assertTrue(checkPixels(reader)); } finally { reader.close(); } }
public static void populatePixelsOnly(MetadataStore store, IFormatReader r) { int oldSeries = r.getSeries(); for (int i=0; i<r.getSeriesCount(); i++) { r.setSeries(i); String pixelType = FormatTools.getPixelTypeString(r.getPixelType()); populatePixelsOnly(store, i, r.isLittleEndian(), r.getDimensionOrder(), pixelType, r.getSizeX(), r.getSizeY(), r.getSizeZ(), r.getSizeC(), r.getSizeT(), r.getRGBChannelCount()); if (store instanceof IPyramidStore) { for (int res=1; res<r.getResolutionCount(); res++) { r.setResolution(res); ((IPyramidStore) store).setResolutionSizeX( new PositiveInteger(r.getSizeX()), i, res); ((IPyramidStore) store).setResolutionSizeY( new PositiveInteger(r.getSizeY()), i, res); } r.setResolution(0); } } r.setSeries(oldSeries); }