Exemple #1
0
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);

    long planeSize = FormatTools.getPlaneSize(this);
    long offset = HEADER_SIZE + extHeaderSize + no * planeSize;

    if (offset + planeSize <= in.length() && offset >= 0) {
      in.seek(offset);
      readPlane(in, x, getSizeY() - h - y, w, h, buf);

      // reverse the order of the rows
      // planes are stored with the origin in the lower-left corner
      byte[] tmp = new byte[w * FormatTools.getBytesPerPixel(getPixelType())];
      for (int row = 0; row < h / 2; row++) {
        int src = row * tmp.length;
        int dest = (h - row - 1) * tmp.length;
        System.arraycopy(buf, src, tmp, 0, tmp.length);
        System.arraycopy(buf, dest, buf, src, tmp.length);
        System.arraycopy(tmp, 0, buf, dest, tmp.length);
      }
    }

    return buf;
  }
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);

    if (getCoreIndex() < core.length - ifds.size()) {
      int tileRows = rows[getCoreIndex()];
      int tileCols = cols[getCoreIndex()];

      Region image = new Region(x, y, w, h);
      int outputRow = 0, outputCol = 0;
      Region intersection = null;

      byte[] tileBuf = null;
      int pixel = getRGBChannelCount() * FormatTools.getBytesPerPixel(getPixelType());
      int outputRowLen = w * pixel;

      for (int row = 0; row < tileRows; row++) {
        for (int col = 0; col < tileCols; col++) {
          int width = tileX[getCoreIndex()];
          int height = tileY[getCoreIndex()];
          Region tile = new Region(col * width, row * height, width, height);
          if (!tile.intersects(image)) {
            continue;
          }

          intersection = tile.intersection(image);
          int intersectionX = 0;

          if (tile.x < image.x) {
            intersectionX = image.x - tile.x;
          }

          tileBuf = decodeTile(no, row, col);

          int rowLen = pixel * (int) Math.min(intersection.width, width);

          int outputOffset = outputRow * outputRowLen + outputCol;
          for (int trow = 0; trow < intersection.height; trow++) {
            int realRow = trow + intersection.y - tile.y;
            int inputOffset = pixel * (realRow * width + intersectionX);
            System.arraycopy(tileBuf, inputOffset, buf, outputOffset, rowLen);
            outputOffset += outputRowLen;
          }

          outputCol += rowLen;
        }

        if (intersection != null) {
          outputRow += intersection.height;
          outputCol = 0;
        }
      }

      return buf;
    } else {
      int ifdIndex = getCoreIndex() - (usedFiles.length - 1);
      return parser.getSamples(ifds.get(ifdIndex), buf, x, y, w, h);
    }
  }
  private void writePixels(String chunk, byte[] stream, int x, int y, int width, int height)
      throws FormatException, IOException {
    MetadataRetrieve r = getMetadataRetrieve();
    int sizeC = getSamplesPerPixel();
    String type = r.getPixelsType(series).toString();
    int pixelType = FormatTools.pixelTypeFromString(type);
    boolean signed = FormatTools.isSigned(pixelType);

    if (!isFullPlane(x, y, width, height)) {
      throw new FormatException("APNGWriter does not support writing tiles.");
    }

    ByteArrayOutputStream s = new ByteArrayOutputStream();
    s.write(chunk.getBytes());
    if (chunk.equals("fdAT")) {
      s.write(DataTools.intToBytes(nextSequenceNumber++, false));
    }
    DeflaterOutputStream deflater = new DeflaterOutputStream(s);
    int planeSize = stream.length / sizeC;
    int rowLen = stream.length / height;
    int bytesPerPixel = stream.length / (width * height * sizeC);
    byte[] rowBuf = new byte[rowLen];
    for (int i = 0; i < height; i++) {
      deflater.write(0);
      if (interleaved) {
        if (littleEndian) {
          for (int col = 0; col < width * sizeC; col++) {
            int offset = (i * sizeC * width + col) * bytesPerPixel;
            int pixel = DataTools.bytesToInt(stream, offset, bytesPerPixel, littleEndian);
            DataTools.unpackBytes(pixel, rowBuf, col * bytesPerPixel, bytesPerPixel, false);
          }
        } else System.arraycopy(stream, i * rowLen, rowBuf, 0, rowLen);
      } else {
        int max = (int) Math.pow(2, bytesPerPixel * 8 - 1);
        for (int col = 0; col < width; col++) {
          for (int c = 0; c < sizeC; c++) {
            int offset = c * planeSize + (i * width + col) * bytesPerPixel;
            int pixel = DataTools.bytesToInt(stream, offset, bytesPerPixel, littleEndian);
            if (signed) {
              if (pixel < max) pixel += max;
              else pixel -= max;
            }
            int output = (col * sizeC + c) * bytesPerPixel;
            DataTools.unpackBytes(pixel, rowBuf, output, bytesPerPixel, false);
          }
        }
      }
      deflater.write(rowBuf);
    }
    deflater.finish();
    byte[] b = s.toByteArray();

    // write chunk length
    out.writeInt(b.length - 4);
    out.write(b);

    // write checksum
    out.writeInt(crc(b));
  }
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);
    if (getSizeC() == 1) {
      return super.openBytes(no, buf, x, y, w, h);
    }

    byte[] b = delegate.openBytes(no / getSizeC(), x, y, w, h);
    int bpp = FormatTools.getBytesPerPixel(getPixelType());
    int c = getZCTCoords(no)[1];
    ImageTools.splitChannels(b, buf, c, getSizeC(), bpp, false, isInterleaved(), w * h * bpp);
    return buf;
  }
Exemple #5
0
 @SuppressWarnings({"rawtypes", "unchecked"})
 private void populatePlane(IFormatReader r, int no, byte[] plane, PlanarAccess planarAccess) {
   final int pixelType = r.getPixelType();
   final int bpp = FormatTools.getBytesPerPixel(pixelType);
   final boolean fp = FormatTools.isFloatingPoint(pixelType);
   final boolean little = r.isLittleEndian();
   Object planeArray = DataTools.makeDataArray(plane, bpp, fp, little);
   if (planeArray == plane) {
     // array was returned by reference; make a copy
     final byte[] planeCopy = new byte[plane.length];
     System.arraycopy(plane, 0, planeCopy, 0, plane.length);
     planeArray = planeCopy;
   }
   planarAccess.setPlane(no, makeArray(planeArray));
 }
  /* @see loci.formats.FormatReader#initFile(String) */
  protected void initFile(String id) throws FormatException, IOException {
    super.initFile(id);
    in = new RandomAccessInputStream(id);
    CoreMetadata m = core.get(0);

    m.littleEndian = true;
    in.order(isLittleEndian());

    while (in.getFilePointer() < MAX_HEADER_SIZE) {
      readVariable();
    }

    in.seek(pixelsOffset);
    m.sizeX = in.readShort();
    pixelsOffset += 2;

    m.sizeY = getSizeX();
    m.pixelType = FormatTools.UINT16;

    m.sizeZ = 1;
    m.sizeC = 1;
    m.sizeT = 1;
    m.imageCount = 1;
    m.dimensionOrder = "XYZCT";

    MetadataStore store = makeFilterMetadata();
    MetadataTools.populatePixels(store, this);
    if (date != null) {
      date = DateTools.formatDate(date, "MMM dd yyyy HH:mm:ssSSS");
      if (date != null) {
        store.setImageAcquisitionDate(new Timestamp(date), 0);
      }
    }

    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
      store.setImageDescription(comment, 0);

      PositiveFloat sizeX = FormatTools.getPhysicalSizeX((double) xSize / getSizeX());
      PositiveFloat sizeY = FormatTools.getPhysicalSizeY((double) xSize / getSizeY());

      if (sizeX != null) {
        store.setPixelsPhysicalSizeX(sizeX, 0);
      }
      if (sizeY != null) {
        store.setPixelsPhysicalSizeY(sizeY, 0);
      }
    }
  }
 /* @see loci.formats.IFormatReader#getOptimalTileHeight() */
 public int getOptimalTileHeight() {
   FormatTools.assertId(currentId, true, 1);
   if (tiffReader.getCurrentFile() == null) {
     setupReader();
   }
   return tiffReader.getOptimalTileHeight();
 }
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    if (getSeriesCount() == 1) return super.openBytes(no, buf, x, y, w, h);

    int[] lengths =
        new int[] {
          getSizeZ(), getEffectiveSizeC(), fieldColumnCount, fieldRowCount, wellCount, getSizeT()
        };

    int[] zct = getZCTCoords(no);
    Well well = getWell(getSeries());
    int[] position = new int[] {zct[0], zct[1], well.fieldCol, well.fieldRow, well.well, zct[2]};

    int fileIndex = FormatTools.positionToRaster(lengths, position);
    RandomAccessInputStream s = null;
    if (fileIndex < files.length) {
      s = new RandomAccessInputStream(files[fileIndex]);
    } else {
      s = new RandomAccessInputStream(files[0]);
    }
    TiffParser parser = new TiffParser(s);
    IFD ifd =
        files.length == 1 ? ifds.get(getSeries() * getImageCount() + no) : parser.getFirstIFD();
    parser.getSamples(ifd, buf, x, y, w, h);
    s.close();

    return buf;
  }
Exemple #9
0
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);

    String file = getFilename(getSeries(), no);
    int field = getSeries() % (fieldRows * fieldCols);
    int fieldRow = field / fieldCols;
    int fieldCol = field % fieldCols;

    if (file != null) {
      try {
        reader.setId(file);
        if (fieldRows * fieldCols == 1) {
          reader.openBytes(0, buf, x, y, w, h);
        } else {
          // fields are stored together in a single image,
          // so we need to split them up
          int fx = x + (fieldCol * getSizeX());
          int fy = y + (fieldRow * getSizeY());
          reader.openBytes(0, buf, fx, fy, w, h);
        }
      } catch (FormatException e) {
        LOGGER.debug("Could not read file " + file, e);
        return buf;
      } catch (IOException e) {
        LOGGER.debug("Could not read file " + file, e);
        return buf;
      }
    }

    return buf;
  }
    public int hashCode() {
      int[] lengths = new int[coordinate.length];
      lengths[0] = rows[getSeries()];
      lengths[1] = cols[getSeries()];

      for (String dim : dimensionOrdering.keySet()) {
        int index = dimensionOrdering.get(dim) + 2;

        if (dim.equals("Z")) {
          lengths[index] = getSizeZ();
        } else if (dim.equals("C")) {
          lengths[index] = getEffectiveSizeC();
        } else if (dim.equals("T")) {
          lengths[index] = getSizeT();
        }
      }

      for (int i = 0; i < lengths.length; i++) {
        if (lengths[i] == 0) {
          lengths[i] = 1;
        }
      }

      return FormatTools.positionToRaster(lengths, coordinate);
    }
Exemple #11
0
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);

    tiffParser.getSamples(ifds.get(getSeries()), buf, x, y, w, h);
    return buf;
  }
Exemple #12
0
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);

    in.seek(pixelsOffset);
    readPlane(in, x, y, w, h, buf);
    return buf;
  }
 /* @see loci.formats.IFormatReader#getOptimalTileHeight() */
 public int getOptimalTileHeight() {
   FormatTools.assertId(currentId, true, 1);
   try {
     return (int) ifds.get(getSeries()).getTileLength();
   } catch (FormatException e) {
     LOGGER.debug("", e);
   }
   return super.getOptimalTileHeight();
 }
  /* @see loci.formats.IFormatReader#getSeriesUsedFiles(boolean) */
  public String[] getSeriesUsedFiles(boolean noPixels) {
    FormatTools.assertId(currentId, true, 1);

    if (noPixels) {
      return files.toArray(new String[files.size()]);
    }
    String[] allFiles = new String[files.size() + 1];
    files.toArray(allFiles);
    allFiles[allFiles.length - 1] = currentId;
    return allFiles;
  }
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);

    String file = positions.get(getSeries()).getFile(no);

    if (file != null && new Location(file).exists()) {
      tiffReader.setId(file);
      return tiffReader.openBytes(0, buf, x, y, w, h);
    }
    LOGGER.warn("File for image #{} ({}) is missing.", no, file);
    return buf;
  }
  /* @see loci.formats.IFormatHandler#openThumbBytes(int) */
  public byte[] openThumbBytes(int no) throws FormatException, IOException {
    FormatTools.assertId(currentId, true, 1);

    int currentSeries = getSeries();
    int thumbSize =
        getThumbSizeX()
            * getThumbSizeY()
            * FormatTools.getBytesPerPixel(getPixelType())
            * getRGBChannelCount();

    if (getCoreIndex() >= usedFiles.length - 1 || usedFiles.length >= core.length) {
      return super.openThumbBytes(no);
    }

    setSeries(usedFiles.length);
    byte[] thumb = FormatTools.openThumbBytes(this, 0);
    setSeries(currentSeries);
    if (thumb.length == thumbSize) {
      return thumb;
    }
    return super.openThumbBytes(no);
  }
 /* @see loci.formats.IFormatReader#getOptimalTileHeight() */
 public int getOptimalTileHeight() {
   FormatTools.assertId(currentId, true, 1);
   if (getCoreIndex() < core.length - ifds.size()) {
     return tileY[getCoreIndex()];
   }
   int ifdIndex = getCoreIndex() - (usedFiles.length - 1);
   try {
     return (int) ifds.get(ifdIndex).getTileLength();
   } catch (FormatException e) {
     LOGGER.debug("Could not retrieve tile height", e);
   }
   return super.getOptimalTileHeight();
 }
  @Override
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.assertId(currentId, true, 1);
    FormatTools.checkPlaneNumber(this, no);
    FormatTools.checkBufferSize(this, buf.length, w, h);

    final int[] zct = FormatTools.getZCTCoords(this, no);

    final byte[] plane;
    try {
      plane = store.getPlane(zct[0], zct[1], zct[2]);
    } catch (ServerError e) {
      throw new FormatException(e);
    }

    RandomAccessInputStream s = new RandomAccessInputStream(plane);
    readPlane(s, x, y, w, h, buf);
    s.close();

    return buf;
  }
Exemple #19
0
  /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
  public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
      throws FormatException, IOException {
    FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);

    int[] zct = getZCTCoords(no);
    int channel = zct[1];
    readers[channel].setId(ndpiFiles[channel]);
    int cIndex = channel < readers[channel].getSizeC() ? channel : 0;
    int plane = readers[channel].getIndex(zct[0], cIndex, zct[2]);

    readers[channel].openBytes(plane, buf, x, y, w, h);

    return buf;
  }
  /* @see loci.formats.IFormatHandler#setId(String) */
  public void setId(String id) throws FormatException, IOException {
    super.setId(id);

    if (out.length() == 0) {
      MetadataRetrieve r = getMetadataRetrieve();
      int width = r.getPixelsSizeX(series).getValue().intValue();
      int height = r.getPixelsSizeY(series).getValue().intValue();
      int bytesPerPixel = FormatTools.getBytesPerPixel(r.getPixelsType(series).toString());
      int nChannels = getSamplesPerPixel();
      boolean indexed = getColorModel() != null && (getColorModel() instanceof IndexColorModel);
      littleEndian = !r.getPixelsBinDataBigEndian(series, 0);

      // write 8-byte PNG signature
      out.write(PNG_SIG);

      // write IHDR chunk

      out.writeInt(13);
      byte[] b = new byte[17];
      b[0] = 'I';
      b[1] = 'H';
      b[2] = 'D';
      b[3] = 'R';

      DataTools.unpackBytes(width, b, 4, 4, false);
      DataTools.unpackBytes(height, b, 8, 4, false);

      b[12] = (byte) (bytesPerPixel * 8);
      if (indexed) b[13] = (byte) 3;
      else if (nChannels == 1) b[13] = (byte) 0;
      else if (nChannels == 2) b[13] = (byte) 4;
      else if (nChannels == 3) b[13] = (byte) 2;
      else if (nChannels == 4) b[13] = (byte) 6;
      b[14] = (byte) 0;
      b[15] = (byte) 0;
      b[16] = (byte) 0;

      out.write(b);
      out.writeInt(crc(b));

      // write acTL chunk

      out.writeInt(8);
      out.writeBytes("acTL");
      numFramesPointer = out.getFilePointer();
      out.writeInt(0);
      out.writeInt(0);
      out.writeInt(0); // save a place for the CRC
    }
  }
 public void populateMetadataStore(String[] jsonData) throws FormatException, IOException {
   FormatTools.assertId(currentId, false, 1);
   currentId = "in-memory-json";
   core = new CoreMetadata[jsonData.length];
   positions = new Vector<Position>();
   for (int pos = 0; pos < jsonData.length; pos++) {
     core[pos] = new CoreMetadata();
     Position p = new Position();
     p.metadataFile = "Position #" + (pos + 1);
     positions.add(p);
     setSeries(pos);
     parsePosition(jsonData[pos], pos);
   }
   setSeries(0);
   populateMetadata();
 }
Exemple #22
0
    /* @see loci.formats.IFormatReader#isThisType(RandomAccessInputStream) */
    public boolean isThisType(RandomAccessInputStream stream) throws IOException {
      final int blockLen = 4;
      if (!FormatTools.validStream(stream, blockLen, false)) return false;

      byte[] signature = new byte[blockLen];
      stream.read(signature);

      if (signature[0] != (byte) 0xff
          || signature[1] != (byte) 0xd8
          || signature[2] != (byte) 0xff
          || ((int) signature[3] & 0xf0) == 0) {
        return false;
      }

      return true;
    }
 /** @see loci.formats.IFormatReader#openBytes(int, byte[], int, int, int, int) */
 public byte[] openBytes(int no, byte[] buf, int x, int y, int w, int h)
     throws FormatException, IOException {
   if (getSeriesCount() == 1) {
     return super.openBytes(no, buf, x, y, w, h);
   }
   FormatTools.checkPlaneParameters(this, no, buf.length, x, y, w, h);
   tiffParser.getSamples(
       ifds.get(series),
       buf,
       x,
       y,
       w,
       h,
       overlaps[getSeries() * 2],
       overlaps[getSeries() * 2 + 1]);
   return buf;
 }
Exemple #24
0
  /* @see loci.formats.IFormatReader#getSeriesUsedFiles(boolean) */
  public String[] getSeriesUsedFiles(boolean noPixels) {
    FormatTools.assertId(currentId, true, 1);

    Vector<String> files = new Vector<String>();
    for (String file : metadataFiles) {
      if (file != null) files.add(file);
    }

    if (!noPixels && tiffs != null) {
      int well = getSeries() / (fieldRows * fieldCols);
      for (int i = 0; i < tiffs[well].length; i++) {
        files.add(tiffs[well][i]);
      }
    }

    return files.toArray(new String[files.size()]);
  }
 /* @see loci.formats.IFormatReader#getSeriesUsedFiles(boolean) */
 public String[] getSeriesUsedFiles(boolean noPixels) {
   FormatTools.assertId(currentId, true, 1);
   Vector<String> files = new Vector<String>();
   for (Position pos : positions) {
     files.add(pos.metadataFile);
     if (pos.xmlFile != null) {
       files.add(pos.xmlFile);
     }
     if (!noPixels) {
       for (String tiff : pos.tiffs) {
         if (new Location(tiff).exists()) {
           files.add(tiff);
         }
       }
     }
   }
   return files.toArray(new String[files.size()]);
 }
 /**
  * Obtains an object which represents a given sub-image of a plane within the file.
  *
  * @param id The path to the file.
  * @param planeNumber The plane or section within the file to obtain.
  * @param buf Pre-allocated buffer which has a <i>length</i> that can fit the byte count of the
  *     sub-image.
  * @param x X coordinate of the upper-left corner of the sub-image
  * @param y Y coordinate of the upper-left corner of the sub-image
  * @param w width of the sub-image
  * @param h height of the sub-image
  * @return an object which represents the sub-image of the plane.
  * @throws FormatException If there is an error parsing the file.
  * @throws IOException If there is an error reading from the file or acquiring permissions to read
  *     the file.
  */
 public PixelData openPlane2D(String id, int planeNumber, byte[] buf, int x, int y, int w, int h)
     throws FormatException, IOException {
   // FIXME: HACK! The ChannelSeparator isn't exactly what one would call
   // "complete" so we have to work around the fact that it still copies
   // all of the plane data (all three channels) from the file if the file
   // is RGB.
   ByteBuffer plane;
   if (iReader.isRGB() || isLeicaReader()) {
     // System.err.println("RGB, not using cached buffer.");
     byte[] bytePlane = openBytes(planeNumber, x, y, w, h);
     plane = ByteBuffer.wrap(bytePlane);
   } else {
     // System.err.println("Not RGB, using cached buffer.");
     plane = ByteBuffer.wrap(openBytes(planeNumber, buf, x, y, w, h));
   }
   plane.order(isLittleEndian() ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
   return new PixelData(FormatTools.getPixelTypeString(getPixelType()), plane);
 }
Exemple #27
0
 @BeforeMethod
 public void setUp() throws Exception {
   fullPlaneCallIndex = 1;
   // No mapping.
   // Location.mapId(TEST_FILE, TEST_FILE);
   reader = new FakeReader();
   try {
     String uuid = UUID.randomUUID().toString();
     idDir = new File(System.getProperty("java.io.tmpdir"), uuid);
     idDir.mkdirs();
     File tempFile = new File(idDir, TEST_FILE);
     tempFile.createNewFile();
     id = tempFile.getAbsolutePath();
     reader.setId(id);
     sizeX = reader.getSizeX();
     sizeY = reader.getSizeY();
     bpp = FormatTools.getBytesPerPixel(reader.getPixelType());
     planeSize = sizeY * sizeY * bpp;
   } finally {
     reader.close();
   }
   reader = new FakeReader(); // No setId !
 }
Exemple #28
0
  /** Copies the current dimensional position into the given array. */
  private void getPosition(IFormatReader r, int no, int[] pos) {
    final int sizeX = r.getSizeX();
    final int sizeY = r.getSizeY();
    final int sizeZ = r.getSizeZ();
    final int sizeT = r.getSizeT();
    // final String[] cDimTypes = r.getChannelDimTypes();
    final int[] cDimLengths = r.getChannelDimLengths();
    final String dimOrder = r.getDimensionOrder();

    final int[] zct = r.getZCTCoords(no);

    int index = 0;
    for (int i = 0; i < dimOrder.length(); i++) {
      final char dim = dimOrder.charAt(i);
      switch (dim) {
        case 'X':
          if (sizeX > 1) index++; // NB: Leave X axis position alone.
          break;
        case 'Y':
          if (sizeY > 1) index++; // NB: Leave Y axis position alone.
          break;
        case 'Z':
          if (sizeZ > 1) pos[index++] = zct[0];
          break;
        case 'T':
          if (sizeT > 1) pos[index++] = zct[2];
          break;
        case 'C':
          final int[] cPos = FormatTools.rasterToPosition(cDimLengths, zct[1]);
          for (int c = 0; c < cDimLengths.length; c++) {
            if (cDimLengths[c] > 1) pos[index++] = cPos[c];
          }
          break;
      }
    }
  }
  public static double[] readImageInfo(String id) {
    try {
      reader.setId(id);
    } catch (FormatException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    // ORDERING: 0 little, 1 seriesCount, 2 pixelType, 3 bpp, 4 itkComponentType, 5 sizeX,
    //           6 sizeY, 7 sizeZ, 8 sizeT, 9 sizeC, 10 effSizeC, 11 rgbChannelCount, 12 imageCount
    //           13 physX, 14 physY, 15 physZ, 16 timeIncrement
    double[] returnValues = new double[17];

    // return this and use SetByteOrderToLittleEndian or SetByteOrderToBigEndian in C++ land
    boolean little = reader.isLittleEndian();

    if (little) {
      returnValues[0] = 1;
    } else {
      returnValues[0] = 0;
    }

    returnValues[1] = reader.getSeriesCount();

    // return bpp and set an IOComponent based on it
    int pixelType = reader.getPixelType();
    returnValues[2] = (double) pixelType;
    returnValues[3] = (double) FormatTools.getBytesPerPixel((int) returnValues[2]);

    // 0 UCHAR, 1 CHAR, 2 USHORT, 3 SHORT, 4 UINT, 5 INT, 6 FLOAT, 7 DOUBLE, 8 UNKNOWN
    if (pixelType == FormatTools.UINT8) returnValues[4] = (double) 0;
    else if (pixelType == FormatTools.INT8) returnValues[4] = (double) 1;
    else if (pixelType == FormatTools.UINT16) returnValues[4] = (double) 2;
    else if (pixelType == FormatTools.INT16) returnValues[4] = (double) 3;
    else if (pixelType == FormatTools.UINT32) returnValues[4] = (double) 4;
    else if (pixelType == FormatTools.INT32) returnValues[4] = (double) 5;
    else if (pixelType == FormatTools.FLOAT) returnValues[4] = (double) 6;
    else if (pixelType == FormatTools.DOUBLE) returnValues[4] = (double) 7;
    else returnValues[4] = (double) 8;

    // return these
    returnValues[5] = (double) reader.getSizeX();
    returnValues[6] = (double) reader.getSizeY();
    returnValues[7] = (double) reader.getSizeZ();
    returnValues[8] = (double) reader.getSizeT();
    returnValues[9] = (double) reader.getSizeC();
    returnValues[10] = (double) reader.getEffectiveSizeC();
    returnValues[11] = (double) reader.getRGBChannelCount();
    returnValues[12] = (double) reader.getImageCount();

    MetadataRetrieve retrieve = MetadataTools.asRetrieve(reader.getMetadataStore());
    Double d = retrieve.getPixelsPhysicalSizeX(0).getValue();
    double d2 = d == null ? 1.0 : d.doubleValue();
    returnValues[13] = d2;
    d = retrieve.getPixelsPhysicalSizeY(0).getValue();
    d2 = d == null ? 1.0 : d.doubleValue();
    returnValues[14] = d2;
    d = retrieve.getPixelsPhysicalSizeZ(0).getValue();
    d2 = d == null ? 1.0 : d.doubleValue();
    returnValues[15] = d2;
    d = retrieve.getPixelsTimeIncrement(0);
    d2 = d == null ? 1.0 : d.doubleValue();
    returnValues[16] = d2;

    return returnValues;
  }
  /**
   * Populates the metadata store using the data parsed in {@link #initStandardMetadata()} along
   * with some further parsing done in the method itself.
   *
   * <p>All calls to the active <code>MetadataStore</code> should be made in this method and
   * <b>only</b> in this method. This is especially important for sub-classes that override the
   * getters for pixel set array size, etc.
   */
  protected void initMetadataStore() throws FormatException {
    LOGGER.info("Populating OME metadata");

    // the metadata store we're working with
    MetadataStore store = makeFilterMetadata();

    IFD firstIFD = ifds.get(0);
    IFD exif = null;

    if (ifds.get(0).containsKey(IFD.EXIF)) {
      try {
        IFDList exifIFDs = tiffParser.getExifIFDs();
        if (exifIFDs.size() > 0) {
          exif = exifIFDs.get(0);
        }
        tiffParser.fillInIFD(exif);
      } catch (IOException e) {
        LOGGER.debug("Could not read EXIF IFDs", e);
      }
    }

    MetadataTools.populatePixels(store, this, exif != null);

    // format the creation date to ISO 8601

    String creationDate = getImageCreationDate();
    String date = DateTools.formatDate(creationDate, DATE_FORMATS);
    if (creationDate != null && date == null) {
      LOGGER.warn("unknown creation date format: {}", creationDate);
    }
    creationDate = date;

    // populate Image

    if (creationDate != null) {
      store.setImageAcquisitionDate(new Timestamp(creationDate), 0);
    }

    if (getMetadataOptions().getMetadataLevel() != MetadataLevel.MINIMUM) {
      // populate Experimenter
      String artist = firstIFD.getIFDTextValue(IFD.ARTIST);

      if (artist != null) {
        String firstName = null, lastName = null;
        int ndx = artist.indexOf(" ");
        if (ndx < 0) lastName = artist;
        else {
          firstName = artist.substring(0, ndx);
          lastName = artist.substring(ndx + 1);
        }
        String email = firstIFD.getIFDStringValue(IFD.HOST_COMPUTER);
        store.setExperimenterFirstName(firstName, 0);
        store.setExperimenterLastName(lastName, 0);
        store.setExperimenterEmail(email, 0);
        store.setExperimenterID(MetadataTools.createLSID("Experimenter", 0), 0);
      }

      store.setImageDescription(firstIFD.getComment(), 0);

      // set the X and Y pixel dimensions

      double pixX = firstIFD.getXResolution();
      double pixY = firstIFD.getYResolution();

      PositiveFloat sizeX = FormatTools.getPhysicalSizeX(pixX);
      PositiveFloat sizeY = FormatTools.getPhysicalSizeY(pixY);

      if (sizeX != null) {
        store.setPixelsPhysicalSizeX(sizeX, 0);
      }
      if (sizeY != null) {
        store.setPixelsPhysicalSizeY(sizeY, 0);
      }
      store.setPixelsPhysicalSizeZ(null, 0);

      if (exif != null) {
        if (exif.containsKey(IFD.EXPOSURE_TIME)) {
          Object exp = exif.get(IFD.EXPOSURE_TIME);
          if (exp instanceof TiffRational) {
            Double exposure = ((TiffRational) exp).doubleValue();
            for (int i = 0; i < getImageCount(); i++) {
              store.setPlaneExposureTime(exposure, 0, i);
            }
          }
        }
      }
    }
  }