public void testExtractMetadata() throws Exception {
   File withExif = new File("Source/com/drew/metadata/exif/test/withExif.jpg");
   Metadata metadata = JpegMetadataReader.readMetadata(withExif);
   assertTrue(metadata.containsDirectory(ExifDirectory.class));
   Directory directory = metadata.getDirectory(ExifDirectory.class);
   assertEquals("80", directory.getString(ExifDirectory.TAG_ISO_EQUIVALENT));
 }
Example #2
0
 private static Directory getMetaDirectory(File file) {
   try {
     Metadata metadata = JpegMetadataReader.readMetadata(file);
     return metadata.getDirectory(ExifDirectory.class);
   } catch (JpegProcessingException e) {
     e.printStackTrace();
   }
   return null;
 }
 @Before
 public void setUp() throws Exception {
   File nikonJpeg = new File("Tests/com/drew/metadata/exif/nikonMakernoteType1.jpg");
   Metadata metadata = JpegMetadataReader.readMetadata(nikonJpeg);
   _nikonDirectory = metadata.getDirectory(NikonType1MakernoteDirectory.class);
   _exifSubIFDDirectory = metadata.getDirectory(ExifSubIFDDirectory.class);
   _exifIFD0Directory = metadata.getDirectory(ExifIFD0Directory.class);
   _thumbDirectory = metadata.getDirectory(ExifThumbnailDirectory.class);
 }
  /* (non-Javadoc)
   * @see org.inbio.m3s.dao.multimedia.MetadataExtractorDAO#init(java.lang.String)
   */
  public void init(String fileAddress) throws IllegalArgumentException {
    logger.info("using the fileAddress: '" + fileAddress + "'");
    this.fileAddress = fileAddress;

    try {
      File jpegFile = new File(fileAddress);
      Metadata metadata = JpegMetadataReader.readMetadata(jpegFile);
      this.exifDirectory = metadata.getDirectory(ExifDirectory.class);

    } catch (JpegProcessingException e) {
      e.printStackTrace();
      throw new IllegalArgumentException(
          "The fileAddress [" + fileAddress + "] doesn't exist. ", e.getCause());
    }
  }
Example #5
0
 private void extractMetadata(UploadItem item, Image image) {
   InputStream in = null;
   try {
     in = new FileInputStream(item.getFile());
     Metadata metadata = JpegMetadataReader.readMetadata(in);
     Directory exifDirectory = metadata.getDirectory(ExifDirectory.class);
     Directory jpgDirectory = metadata.getDirectory(JpegDirectory.class);
     setupCameraModel(image, exifDirectory);
     setupDimensions(image, exifDirectory, jpgDirectory);
     setupCreatedDate(image, exifDirectory);
   } catch (Exception e) {
     addError(item, image, Constants.IMAGE_SAVING_ERROR);
   } finally {
     try {
       in.close();
     } catch (IOException e) {
       addError(item, image, Constants.IMAGE_SAVING_ERROR);
     }
   }
 }
Example #6
0
  public ImageGeo(String filename) {
    try {
      error = false;
      File jpegFile = new File(filename);
      Metadata metadata = JpegMetadataReader.readMetadata(jpegFile);

      GpsDirectory gpsdir = (GpsDirectory) metadata.getDirectory(GpsDirectory.class);
      Rational latpart[] = gpsdir.getRationalArray(GpsDirectory.TAG_GPS_LATITUDE);
      Rational lonpart[] = gpsdir.getRationalArray(GpsDirectory.TAG_GPS_LONGITUDE);
      String northing = gpsdir.getString(GpsDirectory.TAG_GPS_LATITUDE_REF);
      String easting = gpsdir.getString(GpsDirectory.TAG_GPS_LONGITUDE_REF);

      try {
        alt = gpsdir.getDouble(GpsDirectory.TAG_GPS_ALTITUDE);
      } catch (Exception ex) {
      }

      double latsign = 1.0d;
      if (northing.equalsIgnoreCase("S")) latsign = -1.0d;
      double lonsign = 1.0d;
      if (easting.equalsIgnoreCase("W")) lonsign = -1.0d;
      lat =
          (Math.abs(latpart[0].doubleValue())
                  + latpart[1].doubleValue() / 60.0d
                  + latpart[2].doubleValue() / 3600.0d)
              * latsign;
      lon =
          (Math.abs(lonpart[0].doubleValue())
                  + lonpart[1].doubleValue() / 60.0d
                  + lonpart[2].doubleValue() / 3600.0d)
              * lonsign;

      if (Double.isNaN(lat) || Double.isNaN(lon)) error = true;
    } catch (Exception ex) {
      error = true;
    }
    System.out.println(filename + ": (" + lat + ", " + lon + ")");
  }
  /**
   * Reads metadata from an {@link InputStream}.
   *
   * @param inputStream a stream from which the file data may be read. The stream must be positioned
   *     at the beginning of the file's data.
   * @return a populated {@link Metadata} object containing directories of tags with values and any
   *     processing errors.
   * @throws ImageProcessingException if the file type is unknown, or for general processing errors.
   */
  @NotNull
  public static Metadata readMetadata(@NotNull final InputStream inputStream)
      throws ImageProcessingException, IOException {
    BufferedInputStream bufferedInputStream =
        inputStream instanceof BufferedInputStream
            ? (BufferedInputStream) inputStream
            : new BufferedInputStream(inputStream);

    FileType fileType = FileTypeDetector.detectFileType(bufferedInputStream);

    if (fileType == FileType.Jpeg) return JpegMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Tiff
        || fileType == FileType.Arw
        || fileType == FileType.Cr2
        || fileType == FileType.Nef
        || fileType == FileType.Orf
        || fileType == FileType.Rw2) return TiffMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Psd) return PsdMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Png) return PngMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Bmp) return BmpMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Gif) return GifMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Ico) return IcoMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Pcx) return PcxMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Riff) return WebpMetadataReader.readMetadata(bufferedInputStream);

    if (fileType == FileType.Raf) return RafMetadataReader.readMetadata(bufferedInputStream);

    throw new ImageProcessingException("File format is not supported");
  }
  /**
   * Executes the sample usage program.
   *
   * @param args command line parameters
   */
  public static void main(String[] args) {
    File file = new File("Tests/Data/withIptcExifGps.jpg");

    // There are multiple ways to get a Metadata object for a file

    //
    // SCENARIO 1: UNKNOWN FILE TYPE
    //
    // This is the most generic approach.  It will transparently determine the file type and invoke
    // the appropriate
    // readers.  In most cases, this is the most appropriate usage.  This will handle JPEG, TIFF,
    // GIF, BMP and RAW
    // (CRW/CR2/NEF/RW2/ORF) files and extract whatever metadata is available and understood.
    //
    try {
      Metadata metadata = ImageMetadataReader.readMetadata(file);

      print(metadata);
    } catch (ImageProcessingException e) {
      // handle exception
    } catch (IOException e) {
      // handle exception
    }

    //
    // SCENARIO 2: SPECIFIC FILE TYPE
    //
    // If you know the file to be a JPEG, you may invoke the JpegMetadataReader, rather than the
    // generic reader
    // used in approach 1.  Similarly, if you knew the file to be a TIFF/RAW image you might use
    // TiffMetadataReader,
    // PngMetadataReader for PNG files, BmpMetadataReader for BMP files, or GifMetadataReader for
    // GIF files.
    //
    // Using the specific reader offers a very, very slight performance improvement.
    //
    try {
      Metadata metadata = JpegMetadataReader.readMetadata(file);

      print(metadata);
    } catch (JpegProcessingException e) {
      // handle exception
    } catch (IOException e) {
      // handle exception
    }

    //
    // APPROACH 3: SPECIFIC METADATA TYPE
    //
    // If you only wish to read a subset of the supported metadata types, you can do this by
    // passing the set of readers to use.
    //
    // This currently only applies to JPEG file processing.
    //
    try {
      // We are only interested in handling
      Iterable<JpegSegmentMetadataReader> readers =
          Arrays.asList(new ExifReader(), new IptcReader());

      Metadata metadata = JpegMetadataReader.readMetadata(file, readers);

      print(metadata);
    } catch (JpegProcessingException e) {
      // handle exception
    } catch (IOException e) {
      // handle exception
    }
  }
Example #9
0
  private static void extractExif(ImageEntry e) {

    double deg;
    double min, sec;
    double lon, lat;
    Metadata metadata = null;
    Directory dir = null;

    try {
      metadata = JpegMetadataReader.readMetadata(e.getFile());
      dir = metadata.getDirectory(GpsDirectory.class);
    } catch (CompoundException p) {
      e.setExifCoor(null);
      e.setPos(null);
      return;
    }

    try {
      // longitude

      Rational[] components = dir.getRationalArray(GpsDirectory.TAG_GPS_LONGITUDE);

      deg = components[0].doubleValue();
      min = components[1].doubleValue();
      sec = components[2].doubleValue();

      if (Double.isNaN(deg) && Double.isNaN(min) && Double.isNaN(sec))
        throw new IllegalArgumentException();

      lon =
          (Double.isNaN(deg)
              ? 0
              : deg
                  + (Double.isNaN(min) ? 0 : (min / 60))
                  + (Double.isNaN(sec) ? 0 : (sec / 3600)));

      if (dir.getString(GpsDirectory.TAG_GPS_LONGITUDE_REF).charAt(0) == 'W') {
        lon = -lon;
      }

      // latitude

      components = dir.getRationalArray(GpsDirectory.TAG_GPS_LATITUDE);

      deg = components[0].doubleValue();
      min = components[1].doubleValue();
      sec = components[2].doubleValue();

      if (Double.isNaN(deg) && Double.isNaN(min) && Double.isNaN(sec))
        throw new IllegalArgumentException();

      lat =
          (Double.isNaN(deg)
              ? 0
              : deg
                  + (Double.isNaN(min) ? 0 : (min / 60))
                  + (Double.isNaN(sec) ? 0 : (sec / 3600)));

      if (Double.isNaN(lat)) throw new IllegalArgumentException();

      if (dir.getString(GpsDirectory.TAG_GPS_LATITUDE_REF).charAt(0) == 'S') {
        lat = -lat;
      }

      // Store values

      e.setExifCoor(new LatLon(lat, lon));
      e.setPos(e.getExifCoor());

    } catch (CompoundException p) {
      // Try to read lon/lat as double value (Nonstandard, created by some cameras -> #5220)
      try {
        Double longitude = dir.getDouble(GpsDirectory.TAG_GPS_LONGITUDE);
        Double latitude = dir.getDouble(GpsDirectory.TAG_GPS_LATITUDE);
        if (longitude == null || latitude == null) throw new CompoundException("");

        // Store values

        e.setExifCoor(new LatLon(latitude, longitude));
        e.setPos(e.getExifCoor());
      } catch (CompoundException ex) {
        e.setExifCoor(null);
        e.setPos(null);
      }
    } catch (Exception ex) { // (other exceptions, e.g. #5271)
      System.err.println("Error when reading EXIF from file: " + ex);
      e.setExifCoor(null);
      e.setPos(null);
    }

    // compass direction value

    Rational direction = null;

    try {
      direction = dir.getRational(GpsDirectory.TAG_GPS_IMG_DIRECTION);
      if (direction != null) {
        e.setExifImgDir(direction.doubleValue());
      }
    } catch (Exception ex) { // (CompoundException and other exceptions, e.g. #5271)
      // Do nothing
    }
  }