/* @see loci.formats.FormatReader#initFile(String) */ protected void initFile(String id) throws FormatException, IOException { super.initFile(id); reader = new ImageReader(); reader.setMetadataOptions(getMetadataOptions()); reader.setMetadataFiltered(isMetadataFiltered()); reader.setOriginalMetadataPopulated(isOriginalMetadataPopulated()); reader.setNormalized(isNormalized()); reader.setMetadataStore(getMetadataStore()); // NB: We need a raw handle on the ZIP data itself, not a ZipHandle. IRandomAccess rawHandle = Location.getHandle(id, false, false); in = new RandomAccessInputStream(rawHandle, id); ZipInputStream zip = new ZipInputStream(in); while (true) { ZipEntry ze = zip.getNextEntry(); if (ze == null) break; ZipHandle handle = new ZipHandle(id, ze); Location.mapFile(ze.getName(), handle); mappedFiles.add(ze.getName()); } ZipHandle base = new ZipHandle(id); reader.setId(base.getEntryName()); metadataStore = reader.getMetadataStore(); core = reader.getCoreMetadata(); metadata = reader.getGlobalMetadata(); base.close(); }
public static void readPlane( int z, int c, int t, byte[] buf, int xStart, int yStart, int xCount, int yCount) { int no = reader.getIndex(z, c, t); try { reader.openBytes(no, buf, xStart, yStart, xCount, yCount); } catch (FormatException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
public static void dumpOMEXML(String path) throws FormatException, IOException, DependencyException, ServiceException { ServiceFactory serviceFactory = new ServiceFactory(); OMEXMLService omexmlService = serviceFactory.getInstance(OMEXMLService.class); IMetadata meta = omexmlService.createOMEXMLMetadata(); ImageReader r = new ImageReader(); r.setMetadataStore(meta); r.setOriginalMetadataPopulated(true); r.setId(path); r.close(); String xml = omexmlService.getOMEXML(meta); System.out.println(xml); }
/** @return true if reader being used is LeicaReader */ public boolean isLeicaReader() { if (iReader.getReader() instanceof LeicaReader) { return true; } else { return false; } }
public static void close() { try { reader.close(); } catch (IOException e) { e.printStackTrace(); } }
public static boolean canReadFile(String id) { boolean h = false; try { h = reader.isThisType(id); } catch (Exception e) { e.printStackTrace(); } return h; }
/* @see loci.formats.IFormatReader#close(boolean) */ public void close(boolean fileOnly) throws IOException { super.close(fileOnly); if (reader != null) reader.close(fileOnly); if (!fileOnly) reader = null; for (String name : mappedFiles) { IRandomAccess handle = Location.getMappedFile(name); Location.mapFile(name, null); if (handle != null) { handle.close(); } } mappedFiles.clear(); }
private void parseROIs(MetadataStore store) throws FormatException, IOException { if (MetadataTools.isOMEXMLMetadata(store) || MetadataTools.isOMEXMLRoot(store.getRoot())) { return; } String roiID = MetadataTools.createLSID("ROI", 0, 0); String maskID = MetadataTools.createLSID("Shape", 0, 0); store.setROIID(roiID, 0); store.setMaskID(maskID, 0, 0); String positionData = DataTools.readFile(roiDrawFile); String[] coordinates = positionData.split("[ ,]"); double x1 = Double.parseDouble(coordinates[1]); double y1 = Double.parseDouble(coordinates[2]); double x2 = Double.parseDouble(coordinates[3]); double y2 = Double.parseDouble(coordinates[5]); store.setMaskX(x1, 0, 0); store.setMaskY(y1, 0, 0); store.setMaskWidth(x2 - x1, 0, 0); store.setMaskHeight(y2 - y1, 0, 0); store.setImageROIRef(roiID, 0, 0); ImageReader roiReader = new ImageReader(); roiReader.setId(roiFile); byte[] roiPixels = roiReader.openBytes(0); roiReader.close(); BitWriter bits = new BitWriter(roiPixels.length / 8); for (int i = 0; i < roiPixels.length; i++) { bits.write(roiPixels[i] == 0 ? 0 : 1, 1); } store.setMaskBinData(bits.toByteArray(), 0, 0); }
/** Constructs a new pattern reader. */ public FilePatternReader() { super("File pattern", new String[] {"pattern"}); ClassList<IFormatReader> classes = ImageReader.getDefaultReaderClasses(); Class<? extends IFormatReader>[] classArray = classes.getClasses(); ClassList<IFormatReader> newClasses = new ClassList<IFormatReader>(IFormatReader.class); for (Class<? extends IFormatReader> c : classArray) { if (!c.equals(FilePatternReader.class)) { newClasses.addClass(c); } } helper = new FileStitcher(new ImageReader(newClasses)); suffixSufficient = true; }
/** * Wrapper for bio-formats * * @param config - ImportConfit */ public OMEROWrapper(ImportConfig config) { if (config == null) { throw new IllegalArgumentException( "An ImportConfig must be instantitated \n " + "in order to properly configure all readers."); } this.config = config; try { String readersPath = config.readersPath.get(); // Since we now use all readers apart from the ZipReader, just // initialize in this manner which helps us by not requiring // us to keep up with all changes in readers.txt and removes // the requirement for importer_readers.txt (See #2859). // Chris Allan <*****@*****.**> -- Fri 10 Sep 2010 17:24:49 BST ClassList<IFormatReader> readers = ImageReader.getDefaultReaderClasses(); readers.removeClass(ZipReader.class); if (readersPath != null) { Class<?> k = getClass(); if (new File(readersPath).exists()) { k = null; } readers = new ClassList<IFormatReader>(readersPath, IFormatReader.class, k); } iReader = new ImageReader(readers); filler = new ChannelFiller(iReader); } catch (IOException e) { throw new RuntimeException("Unable to load readers.txt."); } reader = separator = new ChannelSeparator(filler); // Force unreadable characters to be removed from metadata key/value pairs iReader.setMetadataFiltered(true); filler.setMetadataFiltered(true); separator.setMetadataFiltered(true); };
/** * 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); }
/* @see loci.formats.IFormatReader#get8BitLookupTable() */ public byte[][] get8BitLookupTable() throws FormatException, IOException { return reader.get8BitLookupTable(); }
/* (non-Javadoc) * @see loci.formats.ReaderWrapper#getMetadataOptions() */ @Override public MetadataOptions getMetadataOptions() { return iReader.getMetadataOptions(); }
/* (non-Javadoc) * @see loci.formats.ReaderWrapper#setMetadataOptions(loci.formats.in.MetadataOptions) */ @Override public void setMetadataOptions(MetadataOptions options) { iReader.setMetadataOptions(options); }
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; }
/* (non-Javadoc) * @see loci.formats.ReaderWrapper#getSupportedMetadataLevels() */ @Override public Set<MetadataLevel> getSupportedMetadataLevels() { return iReader.getSupportedMetadataLevels(); }
public static int getBytesPerPixel() { return FormatTools.getBytesPerPixel(reader.getPixelType()); }
/** @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 { return reader.openBytes(no, buf, x, y, w, h); }
/* @see loci.formats.IFormatReader#get16BitLookupTable() */ public short[][] get16BitLookupTable() throws FormatException, IOException { return reader.get16BitLookupTable(); }
/* @see loci.formats.IFormatReader#setGroupFiles(boolean) */ public void setGroupFiles(boolean groupFiles) { super.setGroupFiles(groupFiles); if (reader != null) reader.setGroupFiles(groupFiles); }
public static boolean getIsInterleaved() { return reader.isInterleaved(); }
public static void main(String[] args) throws DependencyException, FormatException, IOException, ServiceException { if (args.length < 1) { System.out.println("Please specify a (small) image file."); System.exit(1); } String path = args[0]; // read in entire file System.out.println("Reading file into memory from disk..."); File inputFile = new File(path); int fileSize = (int) inputFile.length(); DataInputStream in = new DataInputStream(new FileInputStream(inputFile)); byte[] inBytes = new byte[fileSize]; in.readFully(inBytes); System.out.println(fileSize + " bytes read."); // determine input file suffix String fileName = inputFile.getName(); int dot = fileName.lastIndexOf("."); String suffix = dot < 0 ? "" : fileName.substring(dot); // map input id string to input byte array String inId = "inBytes" + suffix; Location.mapFile(inId, new ByteArrayHandle(inBytes)); // read data from byte array using ImageReader System.out.println(); System.out.println("Reading image data from memory..."); ServiceFactory factory = new ServiceFactory(); OMEXMLService service = factory.getInstance(OMEXMLService.class); IMetadata omeMeta = service.createOMEXMLMetadata(); ImageReader reader = new ImageReader(); reader.setMetadataStore(omeMeta); reader.setId(inId); int seriesCount = reader.getSeriesCount(); int imageCount = reader.getImageCount(); int sizeX = reader.getSizeX(); int sizeY = reader.getSizeY(); int sizeZ = reader.getSizeZ(); int sizeC = reader.getSizeC(); int sizeT = reader.getSizeT(); // output some details System.out.println("Series count: " + seriesCount); System.out.println("First series:"); System.out.println("\tImage count = " + imageCount); System.out.println("\tSizeX = " + sizeX); System.out.println("\tSizeY = " + sizeY); System.out.println("\tSizeZ = " + sizeZ); System.out.println("\tSizeC = " + sizeC); System.out.println("\tSizeT = " + sizeT); // map output id string to output byte array String outId = fileName + ".ome.tif"; ByteArrayHandle outputFile = new ByteArrayHandle(); Location.mapFile(outId, outputFile); // write data to byte array using ImageWriter System.out.println(); System.out.print("Writing planes to destination in memory: "); ImageWriter writer = new ImageWriter(); writer.setMetadataRetrieve(omeMeta); writer.setId(outId); byte[] plane = null; for (int i = 0; i < imageCount; i++) { if (plane == null) { // allow reader to allocate a new byte array plane = reader.openBytes(i); } else { // reuse previously allocated byte array reader.openBytes(i, plane); } writer.saveBytes(i, plane); System.out.print("."); } reader.close(); writer.close(); System.out.println(); byte[] outBytes = outputFile.getBytes(); outputFile.close(); // flush output byte array to disk System.out.println(); System.out.println("Flushing image data to disk..."); File outFile = new File(fileName + ".ome.tif"); DataOutputStream out = new DataOutputStream(new FileOutputStream(outFile)); out.write(outBytes); out.close(); }
public static int getImageCount() { return reader.getImageCount(); }