generate thumbnail using BioFormats

gistfile1.txt

package test;

import java.awt.BorderLayout;
import java.awt.image.BufferedImage;

/*

SEE https://github.com/openmicroscopy/openmicroscopy/blob/develop/components/romio/src/ome/io/bioformats/BfPixelsWrapper.java#L360

 * #%L
 * OME Bio-Formats package for reading and converting biological file formats.
 * %%
 * Copyright (C) 2005 - 2017 Open Microscopy Environment:
 *   - Board of Regents of the University of Wisconsin-Madison
 *   - Glencoe Software, Inc.
 *   - University of Dundee
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 2 of the 
 * License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public 
 * License along with this program.  If not, see
 * <http://www.gnu.org/licenses/gpl-2.0.html>.
 * #L%
 */

import java.io.IOException;
import java.util.List;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

import loci.common.services.DependencyException;
import loci.common.services.ServiceException;
import loci.common.services.ServiceFactory;
import loci.formats.ChannelFiller;
import loci.formats.ChannelMerger;
import loci.formats.ChannelSeparator;
import loci.formats.CoreMetadata;
import loci.formats.FormatException;
import loci.formats.ImageReader;
import loci.formats.gui.AWTImageTools;
import loci.formats.gui.BufferedImageReader;
import loci.formats.meta.IMetadata;
import loci.formats.services.OMEXMLService;

public class GetThumbnail {

	/** The file format reader. */
	private ChannelFiller reader;
	private BufferedImageReader bfreader;

	/** The file to be read. */
	private String inputFile;

	/**
	 * Construct a new FileConvert to convert the specified input file.
	 *
	 * @param inputFile
	 *            the file to be read
	 * @param outputFile
	 *            the file to be written
	 */
	public GetThumbnail(String inputFile) {
		this.inputFile = inputFile;
	}

	/** Do the actual work of converting the input file to the output file. */
	public void convert() {
		// initialize the files
		boolean initializationSuccess = initialize();

		// if we could not initialize one of the files,
		// then it does not make sense to convert the planes
		if (initializationSuccess) {
			convertPlanes();
		}

		// close the files
		cleanup();
	}

	/**
	 * Set up the file reader and writer, ensuring that the input file is
	 * associated with the reader and the output file is associated with the
	 * writer.
	 *
	 * @return true if the reader and writer were successfully set up, or false
	 *         if an error occurred
	 */
	private boolean initialize() {
		Exception exception = null;
		try {
			// construct the object that stores OME-XML metadata
			ServiceFactory factory = new ServiceFactory();
			OMEXMLService service = factory.getInstance(OMEXMLService.class);
			IMetadata omexml = service.createOMEXMLMetadata();

			// set up the reader and associate it with the input file
			ImageReader basereader = new ImageReader();
			ChannelMerger chreader = new ChannelMerger(basereader);
		    reader = new ChannelFiller(chreader);
			reader.setMetadataStore(omexml);
			reader.setId(inputFile);
			bfreader = BufferedImageReader.makeBufferedImageReader(reader);

		} catch (FormatException e) {
			exception = e;
		} catch (IOException e) {
			exception = e;
		} catch (DependencyException e) {
			exception = e;
		} catch (ServiceException e) {
			exception = e;
		}
		if (exception != null) {
			System.err.println("Failed to initialize files.");
			exception.printStackTrace();
		}
		return exception == null;
	}

	public static ImageIcon loadThumb(BufferedImageReader thumbReader, int series) {
		ImageIcon icon = null;
		// open middle image thumbnail in smallest pyramid resolution
		List<CoreMetadata> core = thumbReader.getCoreMetadataList();
		int index = series;
		for (int i = 0; i <= index; i++) {
			if (core.get(i).resolutionCount > 1 && i + core.get(i).resolutionCount > index) {
				index = i + core.get(i).resolutionCount - 1;
				break;
			}
		}
		thumbReader.setSeries(index);

		int z = thumbReader.getSizeZ() / 2;
		int t = thumbReader.getSizeT() / 2;
		int ndx = thumbReader.getIndex(z, 0, t);

		try {
			BufferedImage thumb = thumbReader.openThumbImage(ndx);
			thumb = AWTImageTools.autoscale(thumb);
			icon = new ImageIcon(thumb);
		} catch (FormatException | IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return icon;
	}

	/** Save every plane in the input file to the output file. */
	private void convertPlanes() {
		int series = reader.getSeriesCount() / 2;
		// tell the reader and writer which series to work with
		// in FV1000 OIB/OIF, there are at most two series - one
		// is the actual data, and one is the preview image
		reader.setSeries(series);
		ImageIcon ic = loadThumb(bfreader, series);
		JFrame frame = new JFrame();
		JLabel label = new JLabel(ic);
		frame.getContentPane().add(label, BorderLayout.CENTER);
		frame.pack();
		frame.setVisible(true);
	}

	/** Close the file reader and writer. */
	private void cleanup() {
		try {
			reader.close();
		} catch (IOException e) {
			System.err.println("Failed to cleanup reader and writer.");
			e.printStackTrace();
		}
	}

	/**
	 * To convert a file on the command line:
	 *
	 * $ java FileConvert input-file.oib output-file.ome.tiff
	 */
	public static void main(String[] args) {
		GetThumbnail converter = new GetThumbnail(args[0]);
		converter.convert();
	}

}