import loci.formats.ImageReader; //导入依赖的package包/类
@Deprecated
private int getRealResolutionCount(IFormatReader imageReader) throws IOException, FormatException {
    ImageReader ir = new ImageReader();
    ir.setFlattenedResolutions(false);
    ir.setId(imageReader.getCurrentFile());
    ir.setSeries(imageReader.getSeries());
    int numRes = 1;
    for (int lev=imageReader.getResolutionCount()-1; lev>=0; lev--) {
        numRes = lev;
        ir.setResolution(lev);
        int thumbW = ir.getSizeX();
        int thumbH = ir.getSizeY();
        double diff = Math.abs((thumbW/(double)thumbH) - (imageReader.getSizeX()/(double)imageReader.getSizeY()));
        System.out.println("diff: "+diff);
        if (diff<0.001) break;
    }
    ir.close();
    return numRes;
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
public static final IFormatReader newImageReader(final String id) {
	final IFormatReader reader = new ImageReader();
	
	try {
		reader.setId(id);
	} catch (final Exception exception) {
		throw unchecked(exception);
	}
	
	if ("portable gray map".equals(reader.getFormat().toLowerCase(Locale.ENGLISH))) {
		// XXX This fixes a defect in Bio-Formats PPM loading, but is it always OK?
		reader.getCoreMetadata()[0].interleaved = true;
	}
	
	reader.setSeries(0);
	
	return reader;
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
@Override
public ImageInput identify(ImageInput ii) throws IOException {
    ImageReader reader = new ImageReader();
    try {
        reader.setId(ii.getFile().getAbsolutePath());
    } catch (FormatException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    int width = reader.getSizeX();
    int height = reader.getSizeY();
    String fmt = reader.getFormat();

    String mt = "";
    if (fmt.equalsIgnoreCase("Tagged Image File Format")) {
        mt = "image/tiff";
    } else if (fmt.equalsIgnoreCase("JPEG")) {
        mt = "image/jpeg";
    }

    logger.debug("BioFormats identify: width=" + width + " height=" + height + " format=" + fmt + " mimetype=" + mt);
    ii.setSize(new ImageSize(width, height));
    ii.setMimetype(mt);
    return ii;
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
@Override
protected void typedParse(final RandomAccessInputStream stream,
	final Metadata meta, final SCIFIOConfig config) throws IOException,
	FormatException
{
	try {
		final ImageReader reader = createImageReader(this);
		meta.setReader(reader);

		MetadataStore store = new OMEXMLMetadataImpl();
		reader.setMetadataStore(store);
		reader.setOriginalMetadataPopulated(config.parserIsSaveOriginalMetadata());
		reader.setMetadataFiltered(config.parserIsFiltered());
		reader.setGroupFiles(config.groupableIsGroupFiles());
		reader.setId(stream.getFileName());

		meta.setTable(new DefaultMetaTable(reader.getGlobalMetadata()));
	}
	catch (final loci.formats.FormatException e) {
		throw new FormatException(e);
	}
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
/**
 * Compiles the list of Bio-Formats reader classes, excluding the
 * {@link #DO_NOT_CONVERT} blacklist.
 *
 * @return true if the reader class list was re-generated.
 */
private boolean cacheReaderClasses() {
	final Class<? extends IFormatReader>[] defaultClasses =
		ImageReader.getDefaultReaderClasses().getClasses();
	final int currentHash = Arrays.hashCode(defaultClasses);

	// If our classList is uninitialized, or the Bio-Formats classList has
	// changed, compute the current reader classes.
	if (readerClasses == null || cachedReaderHash != currentHash) {
		final ClassList<IFormatReader> targetClasses =
			new ClassList<IFormatReader>(IFormatReader.class);

		// add reader classes to the list, excluding the blacklist
		for (final Class<? extends IFormatReader> c : defaultClasses) {
			if (convert(c)) targetClasses.addClass(c);
		}
		readerClasses = targetClasses;
		cachedReaderHash = currentHash;

		return true;
	}
	return false;
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
/**
 * @return the suffixes that this predicate considers to be
 *         suffixes of image files.
 */
static public Set<String> getImageSuffixes() {
	synchronized(disallowedSuffixes) {
		if (cachedImageSuffixes == null) {
			cachedImageSuffixes = new HashSet<String>(Arrays.asList(
					new ImageReader().getSuffixes()));
			cachedImageSuffixes.removeAll(disallowedSuffixes);
		}
	}
	return cachedImageSuffixes;
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
@Test
public void testImageReaderInstantiation()
        throws URISyntaxException, FormatException, IOException {
    URL resource = this.getClass().getClassLoader().getResource(
            "org/cellprofiler/imageset/omexml.xml");
    Path path = Paths.get(resource.toURI());

    ImageReader reader = new ImageReader();
    try {
        reader.setId(path.toString());
        assertEquals(4, reader.getSeriesCount());
    } finally {
        reader.close();
    }
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
private IFormatReader createReader(final String filePath)
	throws FormatException, IOException
{
	if (readerPath != null && readerPath.equals(filePath)) {
		// just use the existing reader
		return reader;
	}

	if (reader != null) {
		reader.close();
	}
	System.err.println("Creating new reader for " + filePath);
	// initialize a fresh reader
	final ChannelFiller cf = new ChannelFiller(new ImageReader());
	cf.setFilled(true);
	reader = cf;
	readerPath = filePath;

	reader.setMetadataFiltered(true);
	reader.setOriginalMetadataPopulated(true);
	final MetadataStore store = MetadataTools.createOMEXMLMetadata();
	if (store == null) System.err.println("OME-Java library not found.");
	else reader.setMetadataStore(store);

	// avoid grouping all the .lsm when a .mdb is there
	reader.setGroupFiles(false);

	if (filePath != null) {
		reader.setId(filePath);
		reader.setSeries(0);
	}

	return reader;
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
/**
 * Gets a cached {@link ImageReader}, suitable for using for format checking
 * or suffix generation. Will only instantiate an {@code ImageReader} if
 * necessary.
 */
public ImageReader getCachedImageReader() {
	if (cacheReaderClasses() || cachedReader == null) {
		cachedReader = createImageReader();
	}
	return cachedReader;
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
/** Creates a new Bio-Formats {@link ImageReader}. */
public ImageReader createImageReader() {
	// Check for updated reader classes
	cacheReaderClasses();
	return new ImageReader(readerClasses);
}
 

import loci.formats.ImageReader; //导入依赖的package包/类
public static void main( String[] args ) throws IOException, FormatException
{
	LandmarkTableModel ltm = new LandmarkTableModel( Integer.parseInt( args[ 0 ] ) );
	ltm.load( new File( args[ 1 ] ) );

	ThinPlateR2LogRSplineKernelTransform xfm = ltm.getTransform();

	String srcName = args[ 2 ];
	String template = args[ 3 ];
	String dstName = args[ 4 ];

	ImagePlus impP = IJ.openImage( srcName );

	// read image properties from the header
	ImageReader reader = new ImageReader();
	reader.setId( template );

	String[] names = new String[]{ impP.getTitle(), "target_interval" };

	/* Load the first source */
	final ImagePlusLoader loaderP = new ImagePlusLoader( impP );
	final AbstractSpimData< ? >[] spimDataP = loaderP.loadAll( 0 );
	int numMovingChannels = loaderP.numChannels();

	final AbstractSpimData< ? >[] spimDataQ = new AbstractSpimData[]{ createSpimData( reader ) };
	
	BigWarpExporter< ? > exporter = BigWarpBatchTransformFOV.applyBigWarpHelper( spimDataP, spimDataQ, impP, ltm, Interpolation.NLINEAR );
	
	ImagePlus ipout = exporter.exportMovingImagePlus( false );

	IJ.save( ipout, dstName );

}