/* @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();
}