import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
private static void readFile(final File file) throws FormatException,
	IOException
{
	final SCIFIO scifio = new SCIFIO();
	final Format format =
		scifio.format().getFormat(file.getAbsolutePath(),
			new SCIFIOConfig().checkerSetOpen(true));
	System.out.println("file = " + file);
	System.out.println("format = " + format.getFormatName());
	final Parser parser = format.createParser();
	final Metadata meta = parser.parse(file);
	for (int i = 0; i < meta.getImageCount(); i++) {
		System.out.println("image #" + i + " dimensions:");
		for (int a = 0; a < meta.get(i).getAxes().size(); a++) {
			final AxisType axisType = meta.get(i).getAxis(a).type();
			final long axisLength = meta.get(i).getAxisLength(a);
			System.out.println("\t" + axisLength + " : " + axisType);
		}
	}
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
/**
 * @param reader - An initialized {@link Reader} to use for reading image
 *          data.
 * @param type - The {@link Type} T of the output {@link ImgPlus}, which must
 *          match the typing of the {@link ImgFactory}.
 * @param config - {@link SCIFIOConfig} to use when opening this dataset
 * @return - the {@link ImgPlus} or null
 * @throws ImgIOException if there is a problem reading the image data.
 */
public <T extends RealType<T> & NativeType<T>> List<SCIFIOImgPlus<T>>
	openImgs(final Reader reader, final T type, SCIFIOConfig config)
		throws ImgIOException
{
	if (config == null) {
		config = new SCIFIOConfig().imgOpenerSetComputeMinMax(true);
	}
	final ImgFactoryHeuristic heuristic = getHeuristic(config);

	ImgFactory<T> imgFactory;
	try {
		imgFactory =
			heuristic.createFactory(reader.getMetadata(), config
				.imgOpenerGetImgModes(), type);
	}
	catch (final IncompatibleTypeException e) {
		throw new ImgIOException(e);
	}

	return openImgs(reader, type, imgFactory, config);
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public ByteArrayPlane openPlane(final int imageIndex,
	final long planeIndex, final ByteArrayPlane plane, final long[] planeMin,
	final long[] planeMax, final SCIFIOConfig config) throws FormatException,
	IOException
{
	final Metadata meta = getMetadata();
	final byte[] buf = plane.getBytes();
	FormatTools.checkPlaneForReading(meta, imageIndex, planeIndex,
		buf.length, planeMin, planeMax);

	final String file =
		meta.getPositions().get(imageIndex).getFile(meta, imageIndex,
			planeIndex);

	if (file != null && new Location(getContext(), file).exists()) {
		tiffReader.setSource(file, config);
		return tiffReader.openPlane(imageIndex, 0, plane, planeMin, planeMax);
	}
	log().warn(
		"File for image #" + planeIndex + " (" + file + ") is missing.");
	return plane;
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
/**
 * As {@link #convert(Reader, Writer, String)}, with configuration options.
 *
 * @param input the pre-initialized Reader used for reading data.
 * @param output the uninitialized Writer used for writing data.
 * @param outputFile the full path name of the output file to be created.
 * @param config {@link SCIFIOConfig} to use for the reading and writing.
 * @throws FormatException if there is a general problem reading from or
 *           writing to one of the files.
 * @throws IOException if there is an I/O-related error.
 */
public static void convert(final Reader input, final Writer output,
	final String outputFile, final SCIFIOConfig config) throws FormatException,
	IOException
{

	Plane p = null;

	for (int i = 0; i < input.getImageCount(); i++) {
		for (int j = 0; j < input.getPlaneCount(i); j++) {
			p = input.openPlane(i, j, config);
			output.savePlane(i, j, p);
		}
	}

	input.close();
	output.close();
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
/**
 * Tests that opening datasets with multiple images, via
 * {@link SCIFIOConfig#imgOpenerGetRange()}, is working as intended.
 *
 * @throws ImgIOException
 */
@Test
public void testOpenImageRange() throws ImgIOException {
	final String id = "testImg&images=5&lengths=512,512&axes=X,Y.fake";

	// Open images 0 and 3
	final List<SCIFIOImgPlus<?>> imgs =
		new MultiImgOpener().openImgs(id, new SCIFIOConfig()
			.imgOpenerSetRange("0,3"));

	// Check the size
	assertEquals(2, imgs.size());

	// Check the adjusted dimensions
	assertEquals(imgs.get(0).dimension(0), imgs.get(1).dimension(0) + 30);
	assertEquals(imgs.get(0).dimension(1), imgs.get(1).dimension(1) + 30);
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public BufferedImagePlane openPlane(final int imageIndex,
	final long planeIndex, final BufferedImagePlane plane,
	final long[] planeMin, final long[] planeMax, final SCIFIOConfig config)
	throws FormatException, IOException
{
	final MNGImageInfo info =
		getMetadata().getDatasetInfo().imageInfo.get(imageIndex);
	final long offset = info.offsets.get((int) planeIndex);
	getStream().seek(offset);
	final long end = info.lengths.get((int) planeIndex);
	BufferedImage img = readImage(getMetadata(), end);

	// reconstruct the image to use an appropriate raster
	// ImageIO often returns images that cannot be scaled because a
	// BytePackedRaster is used
	img =
		AWTImageTools.getSubimage(img, getMetadata().get(imageIndex)
			.isLittleEndian(), planeMin, planeMax);

	plane.setData(img);
	return plane;
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public boolean isFormat(String name, final SCIFIOConfig config) {
	if (super.isFormat(name, config)) return true;
	if (!config.checkerIsOpen()) return false;

	// look for a matching .nhdr file
	Location header = new Location(getContext(), name + ".nhdr");
	if (header.exists()) {
		return true;
	}

	if (name.contains(".")) {
		name = name.substring(0, name.lastIndexOf("."));
	}

	header = new Location(getContext(), name + ".nhdr");
	return header.exists();
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public void run() {
	final String omeroSource =
		"server=" + getServer() + //
		"&port=" + getPort() + //
		"&user=" + getUser() + //
		"&password=" + getPassword() + //
		"&imageID=" + imageID + //
		".omero";

	// Force on-demand loading of planes, instead of loading them all up front.
	final SCIFIOConfig config = new SCIFIOConfig();
	config.imgOpenerSetImgModes(ImgMode.CELL);

	try {
		dataset = datasetIOService.open(omeroSource, config);
	}
	catch (IOException exc) {
		log.error(exc);
	}
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public P openPlane(final int imageIndex, final long planeIndex,
	final long[] planeMin, final long[] planeMax, final SCIFIOConfig config)
	throws FormatException, IOException
{
	P plane = null;

	try {
		plane = createPlane(planeMin, planeMax);
	}
	catch (final IllegalArgumentException e) {
		throw new FormatException(
			"Image plane too large. Only 2GB of data can "
				+ "be extracted at one time. You can workaround the problem by opening "
				+ "the plane in tiles; for further details, see: "
				+ "http://www.openmicroscopy.org/site/support/faq/bio-formats/"
				+ "i-see-an-outofmemory-or-negativearraysize-error-message-when-"
				+ "attempting-to-open-an-svs-or-jpeg-2000-file.-what-does-this-mean",
			e);
	}

	return openPlane(imageIndex, planeIndex, plane, planeMin, planeMax, config);
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
/**
 * Write an image to memory using the {@link ImgSaver} and verify that the
 * given {@link ImgPlus} is not corrupted during the process.
 */
@Test
public void testImgPlusIntegrity() throws ImgIOException,
	IncompatibleTypeException
{
	final ImgOpener o = new ImgOpener(ctx);
	final ImgSaver s = new ImgSaver(ctx);
	final SCIFIOConfig config = new SCIFIOConfig().imgOpenerSetImgModes(
		ImgMode.PLANAR);
	final ByteArrayHandle bah = new ByteArrayHandle();
	locationService.mapFile(out, bah);

	final SCIFIOImgPlus<?> openImg = o.openImgs(id, config).get(0);
	final String source = openImg.getSource();
	s.saveImg(out, openImg);
	assertEquals(source, openImg.getSource());
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
protected void
	setSourceHelper(final String source, final SCIFIOConfig config)
{
	final String oldFile = getCurrentFile();
	if (!source.equals(oldFile) ||
		metaCheck() &&
		(((DimensionSwapperMetadata) getMetadata()).getOutputOrder() == null || ((DimensionSwapperMetadata) getMetadata())
			.getOutputOrder().length != getImageCount()))
	{
		@SuppressWarnings("unchecked")
		final List<AxisType>[] axisTypeList = new ArrayList[getImageCount()];
		((DimensionSwapperMetadata) getMetadata()).setOutputOrder(axisTypeList);

		// NB: Create our own copy of the Metadata,
		// which we can manipulate safely.
		// TODO should be a copy method
		if (metaCheck()) ((DimensionSwapperMetadata) getMetadata())
			.wrap(getParent().getMetadata());
	}
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public List<net.imagej.Dataset> openAll(String source)
        throws IOException
{
        final SCIFIOConfig config = new SCIFIOConfig();
        config.imgOpenerSetImgModes(ImgMode.PLANAR);
        return openAll(source, config);
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public M parse(final File file, final SCIFIOConfig config)
	throws IOException, FormatException
{
	@SuppressWarnings("unchecked")
	final M meta = (M) getFormat().createMetadata();
	return parse(file, meta, config);
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
/**
 * @deprecated
 * @see #openImg(String, ImgFactory, SCIFIOConfig)
 */
@Deprecated
@SuppressWarnings("rawtypes")
public static SCIFIOImgPlus<?> openImg(final String source,
	final ImgFactory imgFactory, final SCIFIOConfig config)
{
	return openImgs(source, imgFactory, config).get(0);
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public Plane openPlane(final int imageIndex, final long planeIndex,
	final long[] offsets, final long[] lengths) throws FormatException,
	IOException
{
	return openPlane(imageIndex, planeIndex, offsets, lengths,
		new SCIFIOConfig());
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public void setSource(final RandomAccessInputStream stream,
	final SCIFIOConfig config) throws IOException
{
	if (!getMetadata().versionTwo) {
		stream.close();
		super.setSource(new RandomAccessInputStream(getContext(),
			getMetadata().idsId), config);
	}
	else {
		super.setSource(stream, config);
	}
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
private void read(final int imageIndex, final ImgPlus imgPlus,
	final Reader r, final SCIFIOConfig config, final PlaneConverter converter,
	final long[] planarMin, final long[] planarLength, final Range[] npRanges,
	final long[] npIndices) throws FormatException, IOException
{
	read(imageIndex, imgPlus, r, config, converter, null, planarMin,
		planarLength, npRanges, npIndices, 0, new int[] { 0 });
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public BufferedImagePlane openPlane(final int imageIndex,
	final long planeIndex, final BufferedImagePlane plane,
	final long[] planeMin, final long[] planeMax, final SCIFIOConfig config)
	throws FormatException, IOException
{
	final Metadata meta = getMetadata();
	plane.setData(AWTImageTools.getSubimage(meta.getImg(), meta.get(
		imageIndex).isLittleEndian(), planeMin, planeMax));
	return plane;
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public ByteArrayPlane openPlane(final int imageIndex, final long planeIndex,
	final ByteArrayPlane plane, final long[] planeMin, final long[] planeMax,
	final SCIFIOConfig config) throws FormatException, IOException
{
	final RandomAccessInputStream stream = getStream();
	final Metadata metadata = getMetadata();
	final int offset = (int) (metadata.dataOffset + metadata.sliceBytes * planeIndex);
	stream.seek(offset);
	return readPlane(stream, imageIndex, planeMin, planeMax, plane);
}
 

import io.scif.config.SCIFIOConfig; //导入依赖的package包/类
@Override
public boolean canOpen(final String source) {
	try {
		return formatService.getFormat(source, new SCIFIOConfig()
			.checkerSetOpen(true)) != null;
	}
	catch (final FormatException exc) {
		log.error(exc);
	}
	return false;
}