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;
  }
Exemple #2
0
 private void processFile(File file) throws IOException {
   String fileEx = FileUtility.getFileExtension(file);
   Data data;
   if (fileEx.equals(".jpg") || fileEx.equals(".jpeg")) {
     Metadata meta = null;
     Date[] dates = null;
     try {
       meta = ImageMetadataReader.readMetadata(file);
       dates = PhotoUtility.getData(meta);
     } catch (ImageProcessingException e) {
     } catch (TagNotFound e) {
     } finally {
       if (meta != null && dates != null) data = new Data(file, dates[0], ImageType.JPG, false);
       else data = new Data(file, new Date(file.lastModified()), ImageType.JPG, true);
     }
   } else
     data =
         new Data(
             file,
             new Date(file.lastModified()),
             ImageType.valueOf(fileEx.substring(1).toUpperCase()),
             true);
   notifyFileCountObservers(CountType.SINGEL, ++count);
   notifyImageObservers(data);
 }
 // ----------------------------------------------------------------------------------------------------
 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;
   }
 }
 // ----------------------------------------------------------------------------------------------------
 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_";
   }
 }
  /**
   * 将一个文件转化为 PicMetaInfo 对象
   *
   * @param file
   * @return
   */
  public PicMetaInfo toPicMetaInfo(File file) {
    PicMetaInfo picMetaInfo = null;
    try {
      Metadata metadata = ImageMetadataReader.readMetadata(file);
      picMetaInfo = picInfoReader.toPicMetaInfo(metadata, file);

      return picMetaInfo;
    } catch (Exception e) {
      e.printStackTrace();
      return null;
    }
  }
  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);
  }
 /**
  * Tries to read the EXIF orientation data in the image in the {@link InputStream}. Returns <code>
  * null</code> if not found or if an error occurs.
  */
 @Nullable
 public static ImageOrientation getOrientation(@Nullable final InputStream inputStream) {
   if (inputStream != null) {
     try {
       return getOrientation(
           ImageMetadataReader.readMetadata(new BufferedInputStream(inputStream), true));
     } catch (Exception e) {
       LOG.info(
           "ImageOrientation.getOrientation(): Exception while trying to read the orientation data from the EXIF.  Ignoring and just returning null"
               + e);
     }
   }
   return null;
 }
  /**
   * 打印出单个图片的元信息
   *
   * @throws Exception
   */
  private void printAllMetaInfos() throws Exception {
    String filePath = "E:\\360_sync\\Sync\\Photos\\wallpaper\\DSC07775.JPG";
    Metadata metadata = ImageMetadataReader.readMetadata(new File(filePath));

    for (Directory directory : metadata.getDirectories()) {
      for (Tag tag : directory.getTags()) {
        System.out.format(
            "[%s] - %s = %s\n", directory.getName(), tag.getTagName(), tag.getDescription());
      }
      if (directory.hasErrors()) {
        for (String error : directory.getErrors()) {
          System.err.format("ERROR: %s", error);
        }
      }
    }

    PicMetaInfo info = toPicMetaInfo(new File(filePath));
    System.out.println(info);
  }
Exemple #9
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);
   }
 }
  /**
   * @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;
  }
  /**
   * 保持上传照片的图片方向不发生调整
   *
   * @param filePath 图片的文件路径
   */
  public static void MaintainOrientation(String filePath) {
    try {
      File file = new File(filePath);
      if (!file.exists()) {
        logger.fatal(new FileNotFoundException());
        return;
      }

      Metadata metadata = ImageMetadataReader.readMetadata(file);
      Directory directory = metadata.getFirstDirectoryOfType(ExifIFD0Directory.class);
      int orientation = 0;
      if (null != directory && directory.containsTag(ExifSubIFDDirectory.TAG_ORIENTATION)) {
        orientation = directory.getInt(ExifSubIFDDirectory.TAG_ORIENTATION);
        logger.debug(filePath + " 's orientation is :" + orientation);
      }
      String format = FileUtil.getFileSuffix(filePath);
      switch (orientation) {
          // case 1:
          // return "Top, left side (Horizontal / normal)";
          // case 2:
          // return "Top, right side (Mirror horizontal)";
        case 3:
          // return "Bottom, right side (Rotate 180)";
          BufferedImage old_img3 = (BufferedImage) ImageIO.read(file);
          int w3 = old_img3.getWidth();
          int h3 = old_img3.getHeight();

          BufferedImage new_img3 = new BufferedImage(w3, h3, BufferedImage.TYPE_INT_BGR);
          Graphics2D g2d3 = new_img3.createGraphics();

          AffineTransform origXform3 = g2d3.getTransform();
          AffineTransform newXform3 = (AffineTransform) (origXform3.clone());
          // center of rotation is center of the panel
          // double xRot3 = w3/2.0;
          newXform3.rotate(Math.toRadians(180.0), w3 / 2.0, h3 / 2.0); // 旋转180度

          g2d3.setTransform(newXform3);
          // draw image centered in panel
          g2d3.drawImage(old_img3, 0, 0, null);
          // Reset to Original
          g2d3.setTransform(origXform3);
          // 写到新的文件
          FileOutputStream out3 = new FileOutputStream(file);
          try {
            ImageIO.write(new_img3, format, out3);
          } finally {
            out3.close();
          }

          break;
          // case 4:
          // return "Bottom, left side (Mirror vertical)";
          // case 5:
          // return "Left side, top (Mirror horizontal and rotate 270
          // CW)";
        case 6:
          // return "Right side, top (Rotate 90 CW)";

          BufferedImage old_img6 = (BufferedImage) ImageIO.read(file);
          int w6 = old_img6.getWidth();
          int h6 = old_img6.getHeight();

          BufferedImage new_img6 = new BufferedImage(h6, w6, BufferedImage.TYPE_INT_BGR);
          Graphics2D g2d6 = new_img6.createGraphics();

          AffineTransform origXform6 = g2d6.getTransform();
          AffineTransform newXform6 = (AffineTransform) (origXform6.clone());
          // center of rotation is center of the panel
          double xRot6 = h6 / 2.0;
          newXform6.rotate(Math.toRadians(90.0), xRot6, xRot6); // 旋转90度

          g2d6.setTransform(newXform6);
          // draw image centered in panel
          g2d6.drawImage(old_img6, 0, 0, null);
          // Reset to Original
          g2d6.setTransform(origXform6);
          // 写到新的文件
          FileOutputStream out6 = new FileOutputStream(file);
          try {
            ImageIO.write(new_img6, format, out6);
          } finally {
            out6.close();
          }

          break;
          // case 7:
          // return "Right side, bottom (Mirror horizontal and rotate 90
          // CW)";
        case 8:
          // return "Left side, bottom (Rotate 270 CW)";
          BufferedImage old_img8 = (BufferedImage) ImageIO.read(file);
          int w8 = old_img8.getWidth();
          int h8 = old_img8.getHeight();

          BufferedImage new_img8 = new BufferedImage(h8, w8, BufferedImage.TYPE_INT_BGR);
          Graphics2D g2d8 = new_img8.createGraphics();

          AffineTransform origXform8 = g2d8.getTransform();
          AffineTransform newXform8 = (AffineTransform) (origXform8.clone());
          // center of rotation is center of the panel
          double xRot8 = w8 / 2.0;
          newXform8.rotate(Math.toRadians(270.0), xRot8, xRot8); // 旋转90度

          g2d8.setTransform(newXform8);
          // draw image centered in panel
          g2d8.drawImage(old_img8, 0, 0, null);
          // Reset to Original
          g2d8.setTransform(origXform8);
          // 写到新的文件
          FileOutputStream out8 = new FileOutputStream(file);
          try {
            ImageIO.write(new_img8, format, out8);
          } finally {
            out8.close();
          }

          break;
          // default:
          // return String.valueOf(orientation);
      }
    } catch (Exception e) {
      e.printStackTrace();
      logger.fatal(e);
    }
  }
  /**
   * 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
    }
  }
 /**
  * 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);
 }
 /**
  * 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);
 }
  /**
   * An application entry point. Takes the name of one or more files as arguments and prints the
   * contents of all metadata directories to <code>System.out</code>.
   *
   * <p>If <code>-thumb</code> is passed, then any thumbnail data will be written to a file with
   * name of the input file having <code>.thumb.jpg</code> appended.
   *
   * <p>If <code>-markdown</code> is passed, then output will be in markdown format.
   *
   * <p>If <code>-hex</code> is passed, then the ID of each tag will be displayed in hexadecimal.
   *
   * @param args the command line arguments
   */
  public static void main(@NotNull String[] args) throws MetadataException, IOException {
    Collection<String> argList = new ArrayList<String>(Arrays.asList(args));
    boolean thumbRequested = argList.remove("-thumb");
    boolean markdownFormat = argList.remove("-markdown");
    boolean showHex = argList.remove("-hex");

    if (argList.size() < 1) {
      String version = ImageMetadataReader.class.getPackage().getImplementationVersion();
      System.out.println("metadata-extractor version " + version);
      System.out.println();
      System.out.println(
          String.format(
              "Usage: java -jar metadata-extractor-%s.jar <filename> [<filename>] [-thumb] [-markdown] [-hex]",
              version == null ? "a.b.c" : version));
      System.exit(1);
    }

    for (String filePath : argList) {
      long startTime = System.nanoTime();
      File file = new File(filePath);

      if (!markdownFormat && argList.size() > 1)
        System.out.printf("\n***** PROCESSING: %s\n%n", filePath);

      Metadata metadata = null;
      try {
        metadata = ImageMetadataReader.readMetadata(file);
      } catch (Exception e) {
        e.printStackTrace(System.err);
        System.exit(1);
      }
      long took = System.nanoTime() - startTime;
      if (!markdownFormat)
        System.out.printf(
            "Processed %.3f MB file in %.2f ms%n%n",
            file.length() / (1024d * 1024), took / 1000000d);

      if (markdownFormat) {
        String fileName = file.getName();
        String urlName = StringUtil.urlEncode(filePath);
        ExifIFD0Directory exifIFD0Directory =
            metadata.getFirstDirectoryOfType(ExifIFD0Directory.class);
        String make =
            exifIFD0Directory == null
                ? ""
                : exifIFD0Directory.getString(ExifIFD0Directory.TAG_MAKE);
        String model =
            exifIFD0Directory == null
                ? ""
                : exifIFD0Directory.getString(ExifIFD0Directory.TAG_MODEL);
        System.out.println();
        System.out.println("---");
        System.out.println();
        System.out.printf("# %s - %s%n", make, model);
        System.out.println();
        System.out.printf(
            "<a href=\"https://raw.githubusercontent.com/drewnoakes/metadata-extractor-images/master/%s\">%n",
            urlName);
        System.out.printf(
            "<img src=\"https://raw.githubusercontent.com/drewnoakes/metadata-extractor-images/master/%s\" width=\"300\"/><br/>%n",
            urlName);
        System.out.println(fileName);
        System.out.println("</a>");
        System.out.println();
        System.out.println("Directory | Tag Id | Tag Name | Extracted Value");
        System.out.println(":--------:|-------:|----------|----------------");
      }

      // iterate over the metadata and print to System.out
      for (Directory directory : metadata.getDirectories()) {
        String directoryName = directory.getName();
        for (Tag tag : directory.getTags()) {
          String tagName = tag.getTagName();
          String description = tag.getDescription();

          // truncate the description if it's too long
          if (description != null && description.length() > 1024) {
            description = description.substring(0, 1024) + "...";
          }

          if (markdownFormat) {
            System.out.printf(
                "%s|0x%s|%s|%s%n",
                directoryName, Integer.toHexString(tag.getTagType()), tagName, description);
          } else {
            // simple formatting
            if (showHex) {
              System.out.printf(
                  "[%s - %s] %s = %s%n", directoryName, tag.getTagTypeHex(), tagName, description);
            } else {
              System.out.printf("[%s] %s = %s%n", directoryName, tagName, description);
            }
          }
        }

        // print out any errors
        for (String error : directory.getErrors()) System.err.println("ERROR: " + error);
      }

      if (args.length > 1 && thumbRequested) {
        ExifThumbnailDirectory directory =
            metadata.getFirstDirectoryOfType(ExifThumbnailDirectory.class);
        if (directory != null && directory.hasThumbnailData()) {
          System.out.println("Writing thumbnail...");
          directory.writeThumbnail(args[0].trim() + ".thumb.jpg");
        } else {
          System.out.println("No thumbnail data exists in this image");
        }
      }
    }
  }