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"。

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

 

转载于:https://www.cnblogs.com/zhao1949/p/6473882.html