Example usage for org.apache.commons.imaging.formats.jpeg JpegImageMetadata getPhotoshop

List of usage examples for org.apache.commons.imaging.formats.jpeg JpegImageMetadata getPhotoshop

Introduction

In this page you can find the example usage for org.apache.commons.imaging.formats.jpeg JpegImageMetadata getPhotoshop.

Prototype

public JpegPhotoshopMetadata getPhotoshop() 

Source Link

Usage

From source file:joachimeichborn.geotag.io.jpeg.PictureMetadataWriter.java

private PhotoshopApp13Data getPhotoshopMetadata(final Path aFile)
        throws ImageReadException, IOException, ImageWriteException {
    final ImageMetadata metadata = Imaging.getMetadata(aFile.toFile());
    final JpegImageMetadata jpegMetadata = (JpegImageMetadata) metadata;
    if (jpegMetadata != null) {
        final JpegPhotoshopMetadata photoshopMetadata = jpegMetadata.getPhotoshop();
        if (photoshopMetadata != null) {
            return photoshopMetadata.photoshopApp13Data;
        }//from   w w  w. j av  a 2 s .c  o  m
    }

    return null;
}

From source file:name.hampton.mike.gallery.MetadataExtractor.java

public Map<String, Object> extractImageMetaData(final InputStream inputStream, Map<String, Object> metadataH)
        throws ImageReadException, IOException {
    // get all metadata stored in EXIF format (ie. from JPEG or TIFF).
    final ImageMetadata metadata = Imaging.getMetadata(inputStream, null);

    if (metadata instanceof JpegImageMetadata) {
        final JpegImageMetadata jpegMetadata = (JpegImageMetadata) metadata;

        // Jpeg EXIF metadata is stored in a TIFF-based directory structure
        // and is identified with TIFF tags.
        // Here we look for the "x resolution" tag, but
        // we could just as easily search for any other tag.
        ///*ww w  . j  a  va2  s.c  o  m*/
        // see the TiffConstants file for a list of TIFF tags.

        // out.println("file: " + file.getPath());
        JpegPhotoshopMetadata photoshopmetadata = jpegMetadata.getPhotoshop();
        metadataH.put("photoshop", photoshopmetadata);
        BufferedImage thumbnail = jpegMetadata.getEXIFThumbnail();
        metadataH.put("hasEXIFThumbnail", null != thumbnail);

        Map<String, Object> jpegMetadataH = new HashMap<String, Object>();
        metadataH.put("jpegMetadata", jpegMetadataH);

        // print out various interesting EXIF tags.
        recordTagValue(jpegMetadata, TiffTagConstants.TIFF_TAG_XRESOLUTION, jpegMetadataH);
        recordTagValue(jpegMetadata, TiffTagConstants.TIFF_TAG_DATE_TIME, jpegMetadataH);
        recordTagValue(jpegMetadata, ExifTagConstants.EXIF_TAG_DATE_TIME_ORIGINAL, jpegMetadataH);
        recordTagValue(jpegMetadata, ExifTagConstants.EXIF_TAG_DATE_TIME_DIGITIZED, jpegMetadataH);
        recordTagValue(jpegMetadata, ExifTagConstants.EXIF_TAG_ISO, jpegMetadataH);
        recordTagValue(jpegMetadata, ExifTagConstants.EXIF_TAG_SHUTTER_SPEED_VALUE, jpegMetadataH);
        recordTagValue(jpegMetadata, ExifTagConstants.EXIF_TAG_APERTURE_VALUE, jpegMetadataH);
        recordTagValue(jpegMetadata, ExifTagConstants.EXIF_TAG_BRIGHTNESS_VALUE, jpegMetadataH);
        recordTagValue(jpegMetadata, GpsTagConstants.GPS_TAG_GPS_LATITUDE_REF, jpegMetadataH);
        recordTagValue(jpegMetadata, GpsTagConstants.GPS_TAG_GPS_LATITUDE, jpegMetadataH);
        recordTagValue(jpegMetadata, GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF, jpegMetadataH);
        recordTagValue(jpegMetadata, GpsTagConstants.GPS_TAG_GPS_LONGITUDE, jpegMetadataH);

        // simple interface to GPS data
        final TiffImageMetadata exifMetadata = jpegMetadata.getExif();
        if (null != exifMetadata) {
            final TiffImageMetadata.GPSInfo gpsInfo = exifMetadata.getGPS();
            if (null != gpsInfo) {
                final String gpsDescription = gpsInfo.toString();
                final double longitude = gpsInfo.getLongitudeAsDegreesEast();
                final double latitude = gpsInfo.getLatitudeAsDegreesNorth();

                jpegMetadataH.put("GPSDescription", gpsDescription);
                jpegMetadataH.put("GPSLongitude", longitude);
                jpegMetadataH.put("GPSLatitude", latitude);
            }
            List<TiffField> allFields = exifMetadata.getAllFields();
            List<Map<String, Object>> allFieldsL = new ArrayList<Map<String, Object>>();
            jpegMetadataH.put("allFields", allFieldsL);
            if (null != allFields) {
                for (TiffField field : allFields) {
                    Map<String, Object> fieldH = new HashMap<String, Object>();
                    allFieldsL.add(fieldH);
                    fieldH.put("fieldType", field.getFieldTypeName());
                    if (field.getFieldType().equals(FieldType.RATIONAL)) {
                        // These fields format oddly, must be strings
                        fieldH.put("value", field.getValue().toString());
                    }
                    fieldH.put("descriptionWithoutValue", field.getDescriptionWithoutValue());
                    fieldH.put("directoryType", field.getDirectoryType());
                    fieldH.put("tagName", field.getTagName());
                    fieldH.put("valueDescription", field.getValueDescription());
                }
            }
        }

        // more specific example of how to manually access GPS values
        final TiffField gpsLatitudeRefField = jpegMetadata
                .findEXIFValueWithExactMatch(GpsTagConstants.GPS_TAG_GPS_LATITUDE_REF);
        final TiffField gpsLatitudeField = jpegMetadata
                .findEXIFValueWithExactMatch(GpsTagConstants.GPS_TAG_GPS_LATITUDE);
        final TiffField gpsLongitudeRefField = jpegMetadata
                .findEXIFValueWithExactMatch(GpsTagConstants.GPS_TAG_GPS_LONGITUDE_REF);
        final TiffField gpsLongitudeField = jpegMetadata
                .findEXIFValueWithExactMatch(GpsTagConstants.GPS_TAG_GPS_LONGITUDE);
        if (gpsLatitudeRefField != null && gpsLatitudeField != null && gpsLongitudeRefField != null
                && gpsLongitudeField != null) {
            // all of these values are strings.
            final String gpsLatitudeRef = (String) gpsLatitudeRefField.getValue();
            final RationalNumber gpsLatitude[] = (RationalNumber[]) (gpsLatitudeField.getValue());
            final String gpsLongitudeRef = (String) gpsLongitudeRefField.getValue();
            final RationalNumber gpsLongitude[] = (RationalNumber[]) gpsLongitudeField.getValue();

            final RationalNumber gpsLatitudeDegrees = gpsLatitude[0];
            final RationalNumber gpsLatitudeMinutes = gpsLatitude[1];
            final RationalNumber gpsLatitudeSeconds = gpsLatitude[2];

            final RationalNumber gpsLongitudeDegrees = gpsLongitude[0];
            final RationalNumber gpsLongitudeMinutes = gpsLongitude[1];
            final RationalNumber gpsLongitudeSeconds = gpsLongitude[2];

            // This will format the gps info like so:
            //
            // gpsLatitude: 8 degrees, 40 minutes, 42.2 seconds S
            // gpsLongitude: 115 degrees, 26 minutes, 21.8 seconds E

            Map<String, Object> gpsH = new HashMap<String, Object>();
            jpegMetadataH.put("gps", gpsH);
            Map<String, Object> gpsLatitudeH = new HashMap<String, Object>();
            Map<String, Object> gpsLongitudeH = new HashMap<String, Object>();
            gpsH.put("latitude", gpsLatitudeH);
            gpsH.put("longitude", gpsLongitudeH);

            gpsLatitudeH.put("degrees", gpsLatitudeDegrees.toDisplayString());
            gpsLatitudeH.put("minutes", gpsLatitudeMinutes.toDisplayString());
            gpsLatitudeH.put("seconds", gpsLatitudeSeconds.toDisplayString());
            gpsLatitudeH.put("display", gpsLatitudeRef);
            gpsLongitudeH.put("degrees", gpsLongitudeDegrees.toDisplayString());
            gpsLongitudeH.put("minutes", gpsLongitudeMinutes.toDisplayString());
            gpsLongitudeH.put("seconds", gpsLongitudeSeconds.toDisplayString());
            gpsLongitudeH.put("display", gpsLongitudeRef);

        }
    }
    return metadataH;
}

From source file:net.tourbook.photo.Photo.java

/**
 * Creates metadata from image metadata/*from w  w  w  . j  a v a 2s.  c o m*/
 * 
 * @param imageMetadata
 *            Can be <code>null</code> when not available
 * @return
 */
private PhotoImageMetadata createPhotoMetadata(final IImageMetadata imageMetadata) {

    final PhotoImageMetadata photoMetadata = new PhotoImageMetadata();

    /*
     * read meta data for this photo
     */
    if (imageMetadata instanceof TiffImageMetadata) {

        photoMetadata.isExifFromImage = true;

        final TiffImageMetadata tiffMetadata = (TiffImageMetadata) imageMetadata;

        photoMetadata.exifDateTime = getTiffValueDate(tiffMetadata);

        photoMetadata.orientation = 1;

        photoMetadata.imageWidth = getTiffValueInt(tiffMetadata, TiffTagConstants.TIFF_TAG_IMAGE_WIDTH,
                Integer.MIN_VALUE);

        photoMetadata.imageHeight = getTiffValueInt(tiffMetadata, TiffTagConstants.TIFF_TAG_IMAGE_LENGTH,
                Integer.MIN_VALUE);

        photoMetadata.model = getTiffValueString(tiffMetadata, TiffTagConstants.TIFF_TAG_MODEL);

    } else if (imageMetadata instanceof JpegImageMetadata) {

        photoMetadata.isExifFromImage = true;

        final JpegImageMetadata jpegMetadata = (JpegImageMetadata) imageMetadata;

        photoMetadata.exifDateTime = getExifValueDate(jpegMetadata);

        photoMetadata.orientation = getExifValueInt(jpegMetadata, TiffTagConstants.TIFF_TAG_ORIENTATION, 1);

        photoMetadata.imageWidth = getExifValueInt(jpegMetadata, ExifTagConstants.EXIF_TAG_EXIF_IMAGE_WIDTH,
                Integer.MIN_VALUE);

        photoMetadata.imageHeight = getExifValueInt(jpegMetadata, ExifTagConstants.EXIF_TAG_EXIF_IMAGE_LENGTH,
                Integer.MIN_VALUE);

        photoMetadata.imageDirection = getExifValueDouble(jpegMetadata,
                GpsTagConstants.GPS_TAG_GPS_IMG_DIRECTION);

        photoMetadata.altitude = getExifValueDouble(jpegMetadata, GpsTagConstants.GPS_TAG_GPS_ALTITUDE);

        photoMetadata.model = getExifValueString(jpegMetadata, TiffTagConstants.TIFF_TAG_MODEL);

        /*
         * GPS
         */
        final TiffImageMetadata exifMetadata = jpegMetadata.getExif();
        if (exifMetadata != null) {

            try {
                final TiffImageMetadata.GPSInfo gpsInfo = exifMetadata.getGPS();
                if (gpsInfo != null) {

                    photoMetadata.latitude = gpsInfo.getLatitudeAsDegreesNorth();
                    photoMetadata.longitude = gpsInfo.getLongitudeAsDegreesEast();
                }
            } catch (final Exception e) {
                // ignore
            }
        }
        photoMetadata.gpsAreaInfo = getExifValueGpsArea(jpegMetadata);

        /*
         * photoshop metadata
         */
        final JpegPhotoshopMetadata pshopMetadata = jpegMetadata.getPhotoshop();
        if (pshopMetadata != null) {

            final List<? extends IImageMetadataItem> pshopItems = pshopMetadata.getItems();

            for (final IImageMetadataItem pshopItem : pshopItems) {

                if (pshopItem instanceof Item) {

                    final Item item = (Item) pshopItem;
                    final String keyword = item.getKeyword();

                    if (keyword.equals(IptcTypes.OBJECT_NAME.name)) {

                        photoMetadata.objectName = item.getText();

                    } else if (keyword.equals(IptcTypes.CAPTION_ABSTRACT.name)) {
                        photoMetadata.captionAbstract = item.getText();
                    }
                }
            }

        }
    }

    // set file date time
    photoMetadata.fileDateTime = _imageFileLastModified;

    //// this will log all available meta data
    //      System.out.println(UI.timeStampNano());
    //      System.out.println(UI.timeStampNano() + " " + imageFileName);
    //      System.out.println(UI.timeStampNano());
    //      System.out.println(imageMetadata.toString());
    //      System.out.println(UI.timeStampNano());
    //      System.out.println(photoMetadata);
    //      System.out.println(UI.timeStampNano());
    //      // TODO remove SYSTEM.OUT.PRINTLN

    return photoMetadata;
}