Esempio n. 1
0
  public static Integer readImageOrientation(File imageFile) {
    Metadata metadata = null;
    try {
      metadata = ImageMetadataReader.readMetadata(imageFile);
    } catch (Exception e) {
      // Any exception here is handled as if image
      // format doesn't support EXIF
      return null;
    }

    Directory directory = metadata.getDirectory(ExifIFD0Directory.class);
    JpegDirectory jpegDirectory = (JpegDirectory) metadata.getDirectory(JpegDirectory.class);

    int orientation = 1;

    try {
      orientation = directory.getInt(ExifIFD0Directory.TAG_ORIENTATION);
      /*int width = jpegDirectory.getImageWidth();
      int height = jpegDirectory.getImageHeight();*/
    } catch (Exception e) {
      Logger.warn("Could not get orientation");
    }

    return orientation;
  }
 @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);
 }
 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));
 }
Esempio n. 4
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;
 }
 // ----------------------------------------------------------------------------------------------------
 private String _readExifDateStr(File jpegFile) {
   try {
     Metadata metadata = ImageMetadataReader.readMetadata(jpegFile);
     ExifSubIFDDirectory dir = metadata.getDirectory(ExifSubIFDDirectory.class);
     Date d = dir.getDate(36868);
     return m_sdf.format(d);
   } catch (Exception e) {
     return "_0000-00-00_";
   }
 }
 // ----------------------------------------------------------------------------------------------------
 private long _readExifDate(File jpegFile) {
   try {
     Metadata metadata = ImageMetadataReader.readMetadata(jpegFile);
     ExifSubIFDDirectory dir = metadata.getDirectory(ExifSubIFDDirectory.class);
     Date d = dir.getDate(36868);
     return d.getTime();
   } catch (Exception e) {
     return -1;
   }
 }
Esempio n. 7
0
  /**
   * Performs the Exif data extraction, adding found values to the specified instance of <code>
   * Metadata</code>.
   */
  public Metadata extract(Metadata metadata) {
    if (_data == null) {
      return metadata;
    }

    Directory directory = metadata.getDirectory(IptcDirectory.class);

    // find start of data
    int offset = 0;
    try {
      while (offset < _data.length - 1 && get32Bits(offset) != 0x1c02) {
        offset++;
      }
    } catch (MetadataException e) {
      directory.addError("Couldn't find start of Iptc data (invalid segment)");
      return metadata;
    }

    // for each tag
    while (offset < _data.length) {
      // identifies start of a tag
      if (_data[offset] != 0x1c) {
        break;
      }
      // we need at least five bytes left to read a tag
      if ((offset + 5) >= _data.length) {
        break;
      }

      offset++;

      int directoryType;
      int tagType;
      int tagByteCount;
      try {
        directoryType = _data[offset++];
        tagType = _data[offset++];
        tagByteCount = get32Bits(offset);
      } catch (MetadataException e) {
        directory.addError("Iptc data segment ended mid-way through tag descriptor");
        return metadata;
      }
      offset += 2;
      if ((offset + tagByteCount) > _data.length) {
        directory.addError("data for tag extends beyond end of iptc segment");
        break;
      }

      processTag(directory, directoryType, tagType, offset, tagByteCount);
      offset += tagByteCount;
    }

    return metadata;
  }
Esempio n. 8
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);
     }
   }
 }
  private void scanPictures(String filePath, boolean shared) {
    File file = new File(filePath);

    ContentValues values = new ContentValues();

    String mime = "image/" + FilenameUtils.getExtension(filePath);
    fillCommonValues(values, Constants.FILE_TYPE_PICTURES, filePath, file, mime, shared);

    try {
      Metadata metadata = ImageMetadataReader.readMetadata(file);

      ExifIFD0Directory dir = metadata.getDirectory(ExifIFD0Directory.class);
      ExifIFD0Descriptor desc = new ExifIFD0Descriptor(dir);

      String title = desc.getWindowsTitleDescription();
      if (StringUtils.isNullOrEmpty(title, true)) {
        title = FilenameUtils.getBaseName(file.getName());
      }

      String artist = desc.getWindowsAuthorDescription();
      if (StringUtils.isNullOrEmpty(artist, true)) {
        artist = dir.getString(ExifIFD0Directory.TAG_ARTIST, "UTF-8");
      }
      if (StringUtils.isNullOrEmpty(artist, true)) {
        artist = "";
      }

      String album = "";
      String year = dir.getString(ExifIFD0Directory.TAG_DATETIME);
      if (StringUtils.isNullOrEmpty(year, true)) {
        year = "";
      }

      values.put(Columns.TITLE, title);
      values.put(Columns.ARTIST, artist);
      values.put(Columns.ALBUM, album);
      values.put(Columns.YEAR, year);
    } catch (Throwable e) {
      String displayName = FilenameUtils.getBaseName(file.getName());

      values.put(Columns.TITLE, displayName);
      values.put(Columns.ARTIST, "");
      values.put(Columns.ALBUM, "");
      values.put(Columns.YEAR, "");
    }

    ShareFilesDB db = ShareFilesDB.intance();

    db.insert(values);
  }
Esempio n. 10
0
  /* (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());
    }
  }
Esempio n. 11
0
 /**
  * Tries to read the orientation data from the given image {@link Metadata}. Returns <code>null
  * </code> if not found or if an error occurs.
  */
 @Nullable
 public static ImageOrientation getOrientation(@Nullable final Metadata metadata) {
   if (metadata != null) {
     final Directory exifIfd0Directory = metadata.getDirectory(ExifIFD0Directory.class);
     if (exifIfd0Directory != null) {
       try {
         return findById(exifIfd0Directory.getInt(ExifIFD0Directory.TAG_ORIENTATION));
       } catch (Exception e) {
         LOG.info(
             "ImageOrientation.getOrientation(): Exception while trying to read the orientation data from the EXIF.  Ignoring and just returning null");
       }
     }
   }
   return null;
 }
Esempio n. 12
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 + ")");
  }
Esempio n. 13
0
 protected final Media buildMedia(final MediaUploadBatch context)
     throws MediaReaderException, IOException {
   final String fileName = getFile().getAbsolutePath();
   try {
     final Metadata rawMetadata = ImageMetadataReader.readMetadata(getFile());
     final ExifThumbnailDirectory thumbnailDirectory =
         rawMetadata.getDirectory(ExifThumbnailDirectory.class);
     final byte[] thumbnail;
     if (thumbnailDirectory != null && thumbnailDirectory.hasThumbnailData()) {
       thumbnail = thumbnailDirectory.getThumbnailData();
     } else {
       thumbnail = new byte[0];
     }
     final Map<String, Object> metadata = new HashMap<>(rawMetadata.getDirectoryCount());
     for (final Directory directory : rawMetadata.getDirectories()) {
       copy(directory, metadata);
       preProcess(context, directory, metadata);
     }
     return new Media(getFile(), fileName, context.getTemplate(), metadata, thumbnail);
   } catch (final ImageProcessingException e) {
     throw new MediaReaderException(e);
   }
 }
Esempio n. 14
0
  /**
   * @param filename
   * @return
   */
  private HashMap<String, String> extractExifDatas(String filename) {
    HashMap<String, String> datas = new HashMap<String, String>();
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy_MM_dd_HH'h'mm.ss");
    try {
      File jpegFile = new File(filename);
      Metadata metadata = ImageMetadataReader.readMetadata(jpegFile);

      // reading exif
      ExifSubIFDDirectory directory = metadata.getDirectory(ExifSubIFDDirectory.class);
      if (directory != null) {
        Date date = directory.getDate(ExifSubIFDDirectory.TAG_DATETIME_ORIGINAL);
        if (date != null) {
          datas.put("date", formatter.format(date));
        }
      }
    } catch (JpegProcessingException e) {
      System.err.println("Problem during datas extraction : " + e.getMessage());
    } catch (IOException e) {
      System.err.println("Problem during datas extraction" + e.getMessage());
    } catch (ImageProcessingException e) {
      System.err.println("Problem during datas extraction" + e.getMessage());
    }
    return datas;
  }
 /**
  * Constructor call with a parameter needed
  *
  * @param jpegFile
  * @throws ImageProcessingException
  * @throws IOException
  */
 public EXIFMetadataExtractor(File jpegFile) throws ImageProcessingException, IOException {
   this.metadata = ImageMetadataReader.readMetadata(jpegFile);
   this.directory = (ExifSubIFDDirectory) metadata.getDirectory(ExifSubIFDDirectory.class);
 }
 /**
  * Reads filename and store in private variables
  *
  * @param filename
  * @throws ImageProcessingException
  * @throws IOException
  */
 public void readImageFile(String filename) throws ImageProcessingException, IOException {
   File jpegFile = new File(filename);
   this.metadata = ImageMetadataReader.readMetadata(jpegFile);
   this.directory = (ExifSubIFDDirectory) metadata.getDirectory(ExifSubIFDDirectory.class);
 }
Esempio n. 17
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
    }
  }