import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
@Override
public IImageMetadata getMetadata(final ByteSource byteSource, final Map<String, Object> params)
        throws ImageReadException, IOException {
    final List<PngChunk> chunks = readChunks(byteSource, new ChunkType[] { ChunkType.tEXt, ChunkType.zTXt, }, true);

    if ((chunks == null) || (chunks.isEmpty())) {
        return null;
    }

    final ImageMetadata result = new ImageMetadata();

    for (PngChunk chunk : chunks) {
        final PngTextChunk textChunk = (PngTextChunk) chunk;

        result.add(textChunk.getKeyword(), textChunk.getText());
    }

    return result;
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
/**
 * This method sets the EXIF the of the JPEG file and outputs it to given directory.
 * @param jpegImageFile
 * 		Input jpeg file.
 * @param dst
 * 		output jpeg file.
 * @param longitude
 * 		Longitude to be tagged.
 * @param latitude
 * 	 	Latitude to be tagged.
 * @throws IOException
 * @throws ImageReadException
 * @throws ImageWriteException
 */
public static void setExifGPSTag(final File jpegImageFile, final File dst, final double longitude, final double latitude) throws IOException,
ImageReadException, ImageWriteException {
	OutputStream os = null;
	boolean canThrow = false;
	try {

		final IImageMetadata metadata = Imaging.getMetadata(jpegImageFile);
		final JpegImageMetadata jpegMetadata = (JpegImageMetadata) metadata;
		TiffOutputSet outputSet = setTiffOutputSet(jpegMetadata, longitude, latitude);
		os = new FileOutputStream(dst);
		os = new BufferedOutputStream(os);
		new ExifRewriter().updateExifMetadataLossless(jpegImageFile, os, outputSet);
		canThrow = true;
	} finally {
		IoUtils.closeQuietly(canThrow, os);
	}
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
private static TiffImageMetadata getExif(final File file) {
    TiffImageMetadata exif = null;
    try {
        final IImageMetadata metadata = Imaging.getMetadata(file);
        if (metadata != null) {
            final JpegImageMetadata jpegMetadata
                    = (JpegImageMetadata) metadata;
            exif = jpegMetadata.getExif();
        } else {
            log(Level.WARNING, String.format(
                    "No metadata found for file %s", file));
        }

    }
    catch (final ImageReadException | IOException ex) {
        Logger.getLogger(PhotoLoader.class.getName()).
                log(Level.SEVERE, null, ex);
    }
    return exif;
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
@Override
public IImageMetadata getMetadata(final ByteSource byteSource, final Map<String, Object> params)
        throws ImageReadException, IOException {
    final TiffImageMetadata exif = getExifMetadata(byteSource, params);

    final JpegPhotoshopMetadata photoshop = getPhotoshopMetadata(byteSource,
            params);

    if (null == exif && null == photoshop) {
        return null;
    }

    return new JpegImageMetadata(photoshop, exif);
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
@Override
public IImageMetadata getMetadata(final ByteSource byteSource, final Map<String, Object> params)
        throws ImageReadException, IOException {
    final RgbeInfo info = new RgbeInfo(byteSource);
    boolean canThrow = false;
    try {
        final IImageMetadata ret = info.getMetadata();
        canThrow = true;
        return ret;
    } finally {
        IoUtils.closeQuietly(canThrow, info);
    }
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
IImageMetadata getMetadata() throws IOException, ImageReadException {
    if (null == metadata) {
        readMetadata();
    }

    return metadata;
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
@Override
public IImageMetadata getMetadata(final ByteSource byteSource, final Map<String, Object> params)
        throws ImageReadException, IOException {
    final FormatCompliance formatCompliance = FormatCompliance.getDefault();
    final TiffReader tiffReader = new TiffReader(isStrict(params));
    final TiffContents contents = tiffReader.readContents(byteSource, params,
            formatCompliance);

    final List<TiffDirectory> directories = contents.directories;

    final TiffImageMetadata result = new TiffImageMetadata(contents);

    for (TiffDirectory dir : directories) {
        final TiffImageMetadata.Directory metadataDirectory = new TiffImageMetadata.Directory(
                tiffReader.getByteOrder(), dir);

        final List<TiffField> entries = dir.getDirectoryEntries();

        for (TiffField entry : entries) {
            metadataDirectory.add(entry);
        }

        result.add(metadataDirectory);
    }

    return result;
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
/**
	 * Updated metadata from the image file
	 * 
	 * @param isReadThumbnail
	 * @return Returns image metadata <b>with</b> image thumbnail <b>only</b> when
	 *         <code>isReadThumbnail</code> is <code>true</code>, otherwise it checks if metadata
	 *         are already loaded.
	 */
	public IImageMetadata getImageMetaData(final Boolean isReadThumbnail) {

		if (_photoImageMetadata != null && isReadThumbnail == false) {

			// meta data are available but the exif thumnail is not requested

			return null;
		}

		if (PhotoLoadManager.isImageLoadingError(imageFilePathName)) {
			// image could not be loaded previously
			return null;
		}

		IImageMetadata imageFileMetadata = null;

		try {

			/*
			 * read metadata WITH thumbnail image info, this is the default when the pamameter is
			 * ommitted
			 */
			final HashMap<String, Object> params = new HashMap<String, Object>();
			params.put(ImagingConstants.PARAM_KEY_READ_THUMBNAILS, isReadThumbnail);

//			final long start = System.currentTimeMillis();

			imageFileMetadata = Imaging.getMetadata(imageFile, params);

//			System.out.println(UI.timeStamp()
//					+ Thread.currentThread().getName()
//					+ "read exif\t"
//					+ ((System.currentTimeMillis() - start) + " ms")
//					+ ("\tWithThumb: " + isReadThumbnail)
//					+ ("\t" + imageFilePathName)
//			//
//					);
//			// TODO remove SYSTEM.OUT.PRINTLN
//
//			System.out.println(imageFileMetadata);
//			// TODO remove SYSTEM.OUT.PRINTLN

		} catch (final Exception e) {

			StatusUtil.log(NLS.bind(//
					"Could not read metadata from image \"{0}\"", //$NON-NLS-1$
					imageFile));

			PhotoLoadManager.putPhotoInLoadingErrorMap(imageFilePathName);

		} finally {

			final PhotoImageMetadata photoImageMetadata = createPhotoMetadata(imageFileMetadata);

			updateImageMetadata(photoImageMetadata);
		}

		return imageFileMetadata;
	}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
@Override
public IImageMetadata getMetadata(final ByteSource byteSource, final Map<String, Object> params)
        throws ImageReadException, IOException {
    return null;
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
private static IImageMetadata getMetadata(final ByteSource byteSource, final Map<String, Object> params)
        throws ImageReadException, IOException {
    final ImageParser imageParser = getImageParser(byteSource);

    return imageParser.getMetadata(byteSource, params);
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
/**
 * Get image metadata from the specified file.  Format-specific
 * ImageParser implementations are expected to return a valid
 * IImageMetadata object or to throw an ImageReadException if unable
 * to process the specified data.
 * 
 * <p>The params argument provides a mechanism for individual
 * implementations to pass optional information into the parser.
 * Not all formats will require this capability.  Because the
 * base class may call this method with a null params argument,
 * implementations should <strong>always</strong> include logic
 * for ignoring null input.
 *
 * @param file   A valid reference to a file.
 * @param params Optional instructions for special-handling or
 *               interpretation of the input data (null objects are permitted and
 *               must be supported by implementations).
 * @return A valid image metadata object describing the content extracted
 *         from  the specified content.
 * @throws ImageReadException In the event that the the specified content
 *                            does not conform to the format of the specific
 *                            parser implementation.
 * @throws IOException        In the event of unsuccessful file read or
 *                            access operation.
 */
public final IImageMetadata getMetadata(final File file, final Map<String, Object> params)
        throws ImageReadException, IOException {
    if (getDebug()) {
        System.out.println(getName() + ".getMetadata" + ": "
                + file.getName());
    }

    if (!canAcceptExtension(file)) {
        return null;
    }

    return getMetadata(new ByteSourceFile(file), params);
}
 

import org.apache.commons.imaging.common.IImageMetadata; //导入依赖的package包/类
/**
 * To GeoTag all the images.
 * 
 * @param inputDirectoryPath
 * 		input directory to all the images. 
 * @param kmlDirectoryPath
 * 		Directory in which KML files reside!
 * @param outputDirectoryPath
 * 		Output directory to all the files.
 * @throws ImageReadException
 * @throws IOException
 * @throws ParseException
 * @throws ImageWriteException
 * @throws DatatypeConfigurationException 
 * @throws XMLStreamException 
 */
public static void geoTagAllImages(String inputDirectoryPath, String kmlDirectoryPath, String outputDirectoryPath) throws ImageReadException, IOException, ParseException, ImageWriteException, XMLStreamException, DatatypeConfigurationException{
	File inputDirectory = new File(inputDirectoryPath);
	File[] inputImages = inputDirectory.listFiles();
	Map<When, Coord> kmlMap = loadAllKMLtoMap(kmlDirectoryPath);
	for(File inputImage : inputImages){
		final IImageMetadata metadata = Imaging.getMetadata(inputImage);
		final JpegImageMetadata jpegMetadata = (JpegImageMetadata) metadata;
		File outputImage = new File(outputDirectoryPath, inputImage.getName());
		Long timestamp = getTimeStampFromImage(jpegMetadata);
		Coord coord = KMLUtils.getCoordinateByTime(kmlMap, timestamp, GxEnum.APPROXIMATE);
		setExifGPSTag(inputImage, outputImage, coord.getLatitude(), coord.getLongitude());
	}
}