Java 处理 iphone拍照后 图片EXIF属性翻转90度的方法

http://blog.csdn.net/z69183787/article/details/50320821

Java获取照片EXIF信息
http://blog.csdn.net/ghsau/article/details/8472486

java解决手机等移动设备中照片上传至服务器方向不正确的问题
http://www.bubuko.com/infodetail-715634.html

android 拍照的照片方向问题，读取图片EXIF信息
http://blog.csdn.net/yx0628/article/details/9429795

exif图片方向处理
http://www.codes51.com/article/detail_625107.html
***************************************************

翻转后 orientation 属性为6 。

    public static void main(String[] args) throws ImageProcessingException, IOException {
            File jpegFile= new File("C:\\Users\\Administrator\\Desktop\\IMG_0362.JPG");  

            Metadata metadata = ImageMetadataReader.readMetadata(jpegFile);
            Directory directory = metadata.getDirectory(ExifIFD0Directory.class);
            JpegDirectory jpegDirectory = (JpegDirectory)metadata.getDirectory(JpegDirectory.class);  

    //        int orientation =0;
    //        Metadata metadata = JpegMetadataReader.readMetadata(newFile);
    //        for (Directory directory : metadata.getDirectories())
    //        {
    //            for (Tag tag : directory.getTags())
    //            {
    //                if ("Orientation".equalsIgnoreCase(tag.getTagName()))
    //                {
    //                    orientation=getOrientation(tag.getDescription());
    //                }
    //            }
    //        }
    //        Integer turn=360;
    //        if(orientation==0||orientation==1)
    //        {
    //            turn=360;
    //        }
    //        else if(orientation==3)
    //        {
    //            turn=180;
    //        }
    //        else if(orientation==6)
    //        {
    //            turn=90;
    //        }
    //        else if(orientation==8)
    //        {
    //            turn=270;
    //        }  

            int orientation = 1;
            try {
                orientation = directory.getInt(ExifIFD0Directory.TAG_ORIENTATION);
            } catch (MetadataException me) {
                logger.warn("Could not get orientation");
            }  

            System.out.println(orientation);  

            BufferedImage src = ImageIO.read(jpegFile);
            BufferedImage des = RotateImage.Rotate(src, 90);
            ImageIO.write(des,"jpg", new File("C:\\Users\\Administrator\\Desktop\\IMG_0362.JPG"));  

    //        FileInputStream fip = new FileInputStream(jpegFile);
    //        LLJTran llj = new LLJTran(fip);
    //        try {
    //            llj.read(LLJTran.READ_INFO, true);
    //        } catch (LLJTranException e) {
    //            e.printStackTrace();
    //        }
    //
    //        Exif exif = (Exif) llj.getImageInfo();
    //        Entry e = new Entry(Exif.RATIONAL);
    //        exif.setTagValue(Exif.ORIENTATION_TOPLEFT,1,e,true);
    //        llj.refreshAppx(); // Recreate Marker Data for changes done
    //        //改写后的文件，文件必须存在
    //        OutputStream out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\IMG_0362.JPG"));
    //        // Transfer remaining of image to output with new header.
    //        try {
    //            llj.xferInfo(null, out, LLJTran.REPLACE, LLJTran.REPLACE);
    //        } catch (LLJTranException e1) {
    //            e1.printStackTrace();
    //        }
    //        fip.close();
    //        out.close();
    //        llj.freeMemory();
        }  

        public static int getOrientation(String orientation)
        {
            int tag = 0;
            if ("Top, left side (Horizontal / normal)".equalsIgnoreCase(orientation)) {
                tag = 1;
            } else if ("Top, right side (Mirror horizontal)".equalsIgnoreCase(orientation)) {
                tag = 2;
            } else if ("Bottom, right side (Rotate 180)".equalsIgnoreCase(orientation)) {
                tag = 3;
            } else if ("Bottom, left side (Mirror vertical)".equalsIgnoreCase(orientation)) {
                tag = 4;
            } else if ("Left side, top (Mirror horizontal and rotate 270 CW)".equalsIgnoreCase(orientation)) {
                tag = 5;
            } else if ("Right side, top (Rotate 90 CW)".equalsIgnoreCase(orientation)) {
                tag = 6;
            } else if ("Right side, bottom (Mirror horizontal and rotate 90 CW)".equalsIgnoreCase(orientation)) {
                tag = 7;
            } else if ("Left side, bottom (Rotate 270 CW)".equalsIgnoreCase(orientation)) {
                tag = 8;
            }
            return  tag;
        }  

翻转：

    package com.xxxx.xxx.xxx.xxx;  

    import java.awt.*;
    import java.awt.image.BufferedImage;  

    /**
     * Created by Administrator on 2015/12/15.
     */
    public class RotateImage {
        public static BufferedImage Rotate(Image src, int angel) {
            int src_width = src.getWidth(null);
            int src_height = src.getHeight(null);
            // calculate the new image size
            Rectangle rect_des = CalcRotatedSize(new Rectangle(new Dimension(
                    src_width, src_height)), angel);  

            BufferedImage res = null;
            res = new BufferedImage(rect_des.width, rect_des.height,
                    BufferedImage.TYPE_INT_RGB);
            Graphics2D g2 = res.createGraphics();
            // transform
            g2.translate((rect_des.width - src_width) / 2,
                    (rect_des.height - src_height) / 2);
            g2.rotate(Math.toRadians(angel), src_width / 2, src_height / 2);  

            g2.drawImage(src, null, null);
            return res;
        }  

        public static Rectangle CalcRotatedSize(Rectangle src, int angel) {
            // if angel is greater than 90 degree, we need to do some conversion
            if (angel >= 90) {
                if(angel / 90 % 2 == 1){
                    int temp = src.height;
                    src.height = src.width;
                    src.width = temp;
                }
                angel = angel % 90;
            }  

            double r = Math.sqrt(src.height * src.height + src.width * src.width) / 2;
            double len = 2 * Math.sin(Math.toRadians(angel) / 2) * r;
            double angel_alpha = (Math.PI - Math.toRadians(angel)) / 2;
            double angel_dalta_width = Math.atan((double) src.height / src.width);
            double angel_dalta_height = Math.atan((double) src.width / src.height);  

            int len_dalta_width = (int) (len * Math.cos(Math.PI - angel_alpha
                    - angel_dalta_width));
            int len_dalta_height = (int) (len * Math.cos(Math.PI - angel_alpha
                    - angel_dalta_height));
            int des_width = src.width + len_dalta_width * 2;
            int des_height = src.height + len_dalta_height * 2;
            return new Rectangle(new Dimension(des_width, des_height));
        }
    }  

上述api接口有了变化，已经不能使用，请参考下面的代码

package testExif;

import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;

import javax.imageio.ImageIO;

import com.drew.imaging.jpeg.JpegMetadataReader;
import com.drew.metadata.Directory;
import com.drew.metadata.Metadata;
import com.drew.metadata.exif.ExifDirectoryBase;; 

public class TestExif {

    public static void main(String[] args) throws Exception {
        File file = new File("/pathToJepg/d3805d6c032a42feabce3deee74dfb6a.JPG");
        Metadata metadata = JpegMetadataReader.readMetadata(file);
        Directory directory = metadata.getFirstDirectoryOfType(ExifDirectoryBase.class);
        int orientation=0;
        if(directory != null && directory.containsTag(ExifDirectoryBase.TAG_ORIENTATION)){ // Exif信息中有保存方向,把信息复制到缩略图
            orientation = directory.getInt(ExifDirectoryBase.TAG_ORIENTATION); // 原图片的方向信息
            System.out.println(orientation);
        }

        if(orientation == 1){
            System.out.println("rotate 90");
            BufferedImage src = ImageIO.read(file);
            BufferedImage des = RotateImage.Rotate(src, 270);
            ImageIO.write(des,"jpg", new File("D:/upload/20170224/raw/90.jpg"));
        }
    }
}

图片方向判定

                 if(6 == orientation ){
                       //6旋转90
                       angle = 90;
                   }else if( 3 == orientation){
                      //3旋转180
                       angle = 180;
                   }else if( 8 == orientation){
                      //8旋转90
                       angle = 270;
                   }

总结

上面的RotateImage类可以工作，已经测试了几组照片

*****************

补充:

我们都遇到过这样的情况，拍摄高的景物时，会把相机竖着拍，但是这样得到的图片如果用普通的图片浏览器看景物就是躺着的，需要调整一个角度。

用手机拍照实验(用普通浏览器来看)：

横拿手机右手拍照，照片方向"1""Horizontal"。

正常拿手机竖拍，照片方向"6""Rotate 90 CW"，图片顺时针旋转90度时，即正常。

再转90度，横拿，左手拍照，照片方向"3""Rotate 180",旋转180度即可正常显示方向。

再转90度，手机头朝下拍，照片方向"8""Rotate 270 CW"。

取到这些值，就可以进行相应的操作了。