コード例 #1
0
 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));
 }
コード例 #2
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;
  }
コード例 #3
0
 @Test
 public void testExtractMetadataUsingInputStream() throws Exception {
   File withExif = new File("Tests/com/drew/metadata/exif/withExif.jpg");
   InputStream in = new BufferedInputStream(new FileInputStream((withExif)));
   Metadata metadata = JpegMetadataReader.readMetadata(in);
   Assert.assertTrue(metadata.containsDirectory(ExifSubIFDDirectory.class));
   Directory directory = metadata.getOrCreateDirectory(ExifSubIFDDirectory.class);
   Assert.assertEquals("80", directory.getString(ExifSubIFDDirectory.TAG_ISO_EQUIVALENT));
 }
コード例 #4
0
 @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);
 }
コード例 #5
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;
 }
コード例 #6
0
 // ----------------------------------------------------------------------------------------------------
 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_";
   }
 }
コード例 #7
0
 // ----------------------------------------------------------------------------------------------------
 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;
   }
 }
コード例 #8
0
  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);
  }
コード例 #9
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());
    }
  }
コード例 #10
0
  /**
   * 打印出单个图片的元信息
   *
   * @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);
  }
コード例 #11
0
ファイル: IptcReader.java プロジェクト: starhealthcare/wonder
  /**
   * 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;
  }
コード例 #12
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);
     }
   }
 }
コード例 #13
0
ファイル: ImageGeo.java プロジェクト: Allan1310/maf
  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 + ")");
  }
コード例 #14
0
ファイル: PictureReader.java プロジェクト: edouardhue/comeon
 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);
   }
 }
コード例 #15
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;
  }
コード例 #16
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;
 }
コード例 #17
0
 /**
  * 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);
 }
コード例 #18
0
  /**
   * 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");
        }
      }
    }
  }
コード例 #19
0
 /**
  * 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);
 }
コード例 #20
0
ファイル: GeoImageLayer.java プロジェクト: olejorgenb/josm
  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
    }
  }
コード例 #21
0
  /**
   * 保持上传照片的图片方向不发生调整
   *
   * @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);
    }
  }