通过Java代码获取图片拍摄详细地址和其他相关信息

红太狼 2023-10-04 22:03 32阅读 0赞

## 1 准备工作 ##

### 1.1 导入依赖 ###

<dependency>
                <groupId>com.drewnoakes</groupId>
                <artifactId>metadata-extractor</artifactId>
                <version>2.16.0</version>
            </dependency>

### 1.2 照片图片 ###

![b565f976ea4a46809a4fd70af62bde3e.png][]

图片名和地址如上所述

## 2 具体实现 ##

### 2.1 图片工具类ImageUtils.java ###

package com.wkf.workrecord.utils;
    
    import lombok.extern.slf4j.Slf4j;
    import javax.imageio.ImageIO;
    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.UUID;
    
    /**
     * 图片工具类
     * @author wuKeFan
     * @date 2022-08-30 15:16:07
     */
    @Slf4j
    public class ImageUtils {
    
        public static void main(String[] args) throws Exception {
            ArrayList<String> list = new ArrayList<>();
            list.add("C:\\Users\\1\\Desktop\\rentou.jpg");
            list.add("C:\\Users\\1\\Desktop\\rentou.jpg");
            String path="D://1";
            String resultPath = doVImageMerging2(list, path);
            System.out.println(resultPath);
        }
    
        //2张图片水平合并
        public static String doVImageMerging2(ArrayList<String> list, String pathFile) {
            // 读取待合并的文件
            BufferedImage bi1 = null;
            BufferedImage bi2 = null;
            // 调用mergeImage方法获得合并后的图像
            BufferedImage destImg = null;
            try {
                bi2 = getBufferedImage(list.get(0));
                bi1 = getBufferedImage(list.get(1));
            } catch (IOException e) {
                e.printStackTrace();
            }
            // 调用mergeImage方法获得合并后的图像
            try {
                if (bi1 != null && bi2 != null) {
                    destImg = mergeImage(bi1, bi2, false);//true为水平，false为垂直
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            // 保存图像
            String savePath = pathFile + "/";//文件存放路径
            String fileName = createImageName() + ".jpg";//文件名称
            String fileType = "jpg";//文件格式
            boolean result = saveImage(destImg, savePath, fileName, fileType);
            log.info("图片保存结果:{}", result ? "成功" : "失败");
            return savePath + fileName;
        }
        public static BufferedImage getBufferedImage(String fileUrl) throws IOException {
            File f = new File(fileUrl);
            return ImageIO.read(f);
        }
        /**
         * 待合并的两张图必须满足这样的前提，如果水平方向合并，则高度必须相等；如果是垂直方向合并，宽度必须相等。
         * mergeImage方法不做判断，自己判断。
         *
         * @param img1
         * 待合并的第一张图
         * @param img2
         * 带合并的第二张图
         * @param isHorizontal
         * 为true时表示水平方向合并，为false时表示垂直方向合并
         * @return 返回合并后的BufferedImage对象
         */
        public static BufferedImage mergeImage(BufferedImage img1, BufferedImage img2, boolean isHorizontal) throws IOException {
            int w1 = img1.getWidth();
            int h1 = img1.getHeight();
            int w2 = img2.getWidth();
            int h2 = img2.getHeight();
            // 从图片中读取RGB
            int[] ImageArrayOne = new int[w1 * h1];
            ImageArrayOne = img1.getRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 逐行扫描图像中各个像素的RGB到数组中
            int[] ImageArrayTwo = new int[w2 * h2];
            ImageArrayTwo = img2.getRGB(0, 0, w2, h2, ImageArrayTwo, 0, w2);
            // 生成新图片
            BufferedImage DestImage;
            // 水平方向合并
            if (isHorizontal) {
            // DestImage = new BufferedImage(w1+w2, h1, BufferedImage.TYPE_INT_RGB);
                Graphics2D g2d;
                if (h1 >= h2) {
                    DestImage = new BufferedImage(w1 + w2, h1, BufferedImage.TYPE_INT_RGB);
                } else {
                    DestImage = new BufferedImage(w2, h1, BufferedImage.TYPE_INT_RGB);//TYPE_INT_RGB
                }
                g2d = DestImage.createGraphics();
                g2d.setPaint(Color.WHITE);
                g2d.fillRect(0, 0, w1 + w2, h1);
                g2d.dispose();
                DestImage.setRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 设置上半部分或左半部分的RGB
                DestImage.setRGB(w1, 0, w2, h2, ImageArrayTwo, 0, w2);
            } else { // 垂直方向合并
                Graphics2D g2d;
                if (w1 >= w2) {
                    DestImage = new BufferedImage(w1, h1 + h2, BufferedImage.TYPE_INT_RGB);//TYPE_INT_RGB
                } else {
                    DestImage = new BufferedImage(w2, h1 + h2, BufferedImage.TYPE_INT_RGB);//TYPE_INT_RGB
                }
                g2d = DestImage.createGraphics();
                g2d.setPaint(Color.WHITE);
                g2d.fillRect(0, 0, w1 + w2, h1 + h2);
                g2d.dispose();
                DestImage.setRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 设置上半部分或左半部分的RGB
                DestImage.setRGB(0, h1, w2, h2, ImageArrayTwo, 0, w2); // 设置下半部分的RGB
            }
            return DestImage;
        }
        //随机生成图片名称
        public static String createImageName() {
            // 创建 GUID 对象
            UUID uuid = UUID.randomUUID();
            // 得到对象产生的ID
            String a = uuid.toString();
            // 转换为大写
            a = a.toUpperCase();
            // 替换 -
            a = a.replaceAll("-", "");
            return a;
        }
        public static boolean saveImage(BufferedImage savedImg, String saveDir, String fileName, String format) {
            boolean flag = false;
            // 先检查保存的图片格式是否正确
            String[] legalFormats = { "jpg", "JPG", "png", "PNG", "bmp", "BMP" };
            int i;
            for (i = 0; i < legalFormats.length; i++) {
                if (format.equals(legalFormats[i])) {
                    break;
                }
            }
            if (i == legalFormats.length) { // 图片格式不支持
                System.out.println("不是保存所支持的图片格式!");
                return false;
            }
            // 再检查文件后缀和保存的格式是否一致
            String postfix = fileName.substring(fileName.lastIndexOf('.') + 1);
            if (!postfix.equalsIgnoreCase(format)) {
                System.out.println("待保存文件后缀和保存的格式不一致!");
                return false;
            }
            String fileUrl = saveDir + fileName;
            File file = new File(fileUrl);
            try {
                flag = ImageIO.write(savedImg, format, file);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return flag;
        }
    
        /**
         * 经纬度格式  转换为  度分秒格式 ,如果需要的话可以调用该方法进行转换
         *
         * @param point 坐标点
         * @return 返回时分秒格式
         */
        public static String pointToLatLong(String point) {
            double du = Double.parseDouble(point.substring(0, point.indexOf("°")).trim());
            double fen = Double.parseDouble(point.substring(point.indexOf("°") + 1, point.indexOf("'")).trim());
            double miao = Double.parseDouble(point.substring(point.indexOf("'") + 1, point.indexOf("\"")).trim());
            double duStr = du + fen / 60 + miao / 60 / 60;
            return Double.toString(duStr);
        }
    
        /***
         * 经纬度坐标格式转换（* °转十进制格式）
         * @param gps gps坐标
         */
        public static double latLng2Decimal(String gps) {
            String a = gps.split("°")[0].replace(" ", "");
            String b = gps.split("°")[1].split("'")[0].replace(" ", "");
            String c = gps.split("°")[1].split("'")[1].replace(" ", "").replace("\"", "");
            return Double.parseDouble(a) + Double.parseDouble(b) / 60 + Double.parseDouble(c) / 60 / 60;
        }
    
    }

### 2.2 地址处理工具类(主要逻辑代码都在这个类)ImageAddressUtils.java ###

package com.wkf.workrecord.tools.photo.address.utils;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.drew.imaging.ImageMetadataReader;
    import com.drew.imaging.ImageProcessingException;
    import com.drew.metadata.Directory;
    import com.drew.metadata.Metadata;
    import com.drew.metadata.Tag;
    import com.wkf.workrecord.tools.baidu.map.BaiduMapConstants;
    import com.wkf.workrecord.tools.photo.address.entity.AddressComponentResponse;
    import com.wkf.workrecord.tools.photo.address.entity.ReverseGeocodingRequest;
    import com.wkf.workrecord.utils.ImageUtils;
    import com.wkf.workrecord.utils.ObjectUtils;
    import com.wkf.workrecord.utils.fuying.RegexUtils;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Component;
    import org.springframework.web.client.RestTemplate;
    
    import javax.annotation.Resource;
    import java.io.File;
    import java.io.IOException;
    import java.util.Map;
    import java.util.Objects;
    
    /**
     * 图片地址工具类
     * @author wuKeFan
     * @date 2023-02-24 15:44:31
     */
    @Slf4j
    @Component
    public class ImageAddressUtils {
    
        @Resource
        private RestTemplate restTemplate;
    
        public String getPhotoAddress(String fileName) throws ImageProcessingException, IOException {
            File file = new File(fileName);
            Metadata metadata = ImageMetadataReader.readMetadata(file);
            //图片的所有目录信息
            Iterable<Directory> directories = metadata.getDirectories();
            for (Directory directory : directories) {
                for (Tag tag : directory.getTags()) {
                    log.info("[{}] - {} = {}",
                            directory.getName(), tag.getTagName(), tag.getDescription());
                }
                if (directory.hasErrors()) {
                    for (String error : directory.getErrors()) {
                        log.info("ERROR: {}", error);
                    }
                }
            }
            Double lat = null;
            Double lng = null;
            for (Directory directory : directories) {
                for (Tag tag : directory.getTags()) {
                    String tagName = tag.getTagName();  //标签名
                    String desc = tag.getDescription(); //标签信息
                    switch (tagName) {
                        case "Image Height":
                            log.info("图片高度: " + desc);
                            break;
                        case "Image Width":
                            log.info("图片宽度: " + desc);
                            break;
                        case "Date/Time Original":
                            log.info("拍摄时间: " + desc);
                            break;
                        case "GPS Latitude":
                            log.info("纬度 : " + desc);
                            log.info("纬度(度分秒格式) : " + ImageUtils.pointToLatLong(desc));
                            lat = ImageUtils.latLng2Decimal(desc);
                            break;
                        case "GPS Longitude":
                            log.info("经度: " + desc);
                            log.info("经度(度分秒格式): " + ImageUtils.pointToLatLong(desc));
                            lng = ImageUtils.latLng2Decimal(desc);
                            break;
                    }
                }
            }
            //经纬度转地主使用百度api
            if (lat != null && lng != null) {
                ReverseGeocodingRequest request = ReverseGeocodingRequest.builder()
                        .token(BaiduMapConstants.BAIDU_MAP_TOKEN).output(BaiduMapConstants.OUTPUT_TYPE_JSON)
                        .coordinateType(BaiduMapConstants.COORDINATE_TYPE_GPS).lat(lat).lng(lng)
                        .build();
                Map<String, Object> map = ObjectUtils.objectToMap(request);
                String result = restTemplate.getForObject(BaiduMapConstants.REVERSE_GEOCODING_URL, String.class, map);
                JSONObject resultObj = JSONObject.parseObject(RegexUtils.underlineToHump(result));
                if (resultObj != null && Objects.equals(resultObj.getInteger("status"), 0)) {
                    AddressComponentResponse response = resultObj.getJSONObject("result").getObject("addressComponent", AddressComponentResponse.class);
                    return "拍摄地点：" + response.getCountry() + " " + response.getProvince() + " " + response.getCity() + " " + response.getDirection() + " "
                            + response.getStreet() + " " + resultObj.getJSONObject("result").get("formattedAddress") + " " + resultObj.getJSONObject("result").get("business");
                }
            }
            return null;
        }
    
    }

### 2.3 实体类AddressComponentResponse.java和ReverseGeocodingRequest.java ###

package com.wkf.workrecord.tools.photo.address.entity;
    
    import lombok.Data;
    
    /**
     * 地址构成实体类
     * @author wuKeFan
     * @date 2022-08-18 14:48:28
     */
    @Data
    public class AddressComponentResponse {
    
        /**
         * 国家
         */
        private String country;
    
        /**
         * 国家编码
         */
        private int countryCode;
    
        /**
         * 国家英文缩写（三位）
         */
        private String countryCodeIso;
    
        /**
         * 国家英文缩写（两位）
         */
        private String countryCodeIso2;
    
        /**
         * 省名
         */
        private String province;
    
        /**
         * 城市名
         */
        private String city;
    
        /**
         * 城市所在级别（仅国外有参考意义。
         * 国外行政区划与中国有差异，城市对应的层级不一定为『city』。
         * country、province、city、district、town分别对应0-4级，
         * 若city_level=3，则district层级为该国家的city层级）
         */
        private int cityLevel;
    
        /**
         * 区县名
         */
        private String district;
    
        /**
         * 乡镇名，需设置extensions_town=true时才会返回
         */
        private String town;
    
        /**
         * 乡镇id
         */
        private String townCode;
    
        /**
         * 相对当前坐标点的距离，
         * 当有门牌号的时候返回数据
         */
        private String distance;
    
        /**
         * 和当前坐标点的方向
         */
        private String direction;
    
        /**
         * 行政区划代码
         */
        private String adcode;
    
        /**
         * 街道名（行政区划中的街道层级）
         */
        private String street;
    
        /**
         * 街道门牌号
         */
        private String streetNumber;
    
    }

package com.wkf.workrecord.tools.photo.address.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * 逆地理编码参数请求实体类
     * @author wuKeFan
     * @date 2022-08-18 14:29:15
     */
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    public class ReverseGeocodingRequest {
    
        /**
         * 用户申请注册的key,即ak
         */
        private String token;
    
        /**
         * 输出格式为json或者xml
         */
        private String output;
    
        /**
         * 坐标的类型，
         * 目前支持的坐标类型包括：bd09ll（百度经纬度坐标）、
         * bd09mc（百度米制坐标）、gcj02ll（国测局经纬度坐标，仅限中国）、wgs84ll（ GPS经纬度）
         */
        private String coordinateType;
    
        /**
         * 纬度
         */
        private Double lat;
    
        /**
         * 经度
         */
        private Double lng;
    
    }

### 2.4 测试代码 ###

package com.wkf.workrecord.study;
    
    import com.drew.imaging.ImageProcessingException;
    import com.wkf.workrecord.tools.photo.address.utils.ImageAddressUtils;
    import lombok.extern.slf4j.Slf4j;
    import org.junit.jupiter.api.Test;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.web.client.RestTemplate;
    import javax.annotation.Resource;
    import java.io.IOException;
    
    /**
     * 公共测试类
     * @author wuKeFan
     * @date 2023-02-20 09:53:14
     */
    @Slf4j
    @SpringBootTest
    public class PublicTest {
    
        @Resource
        private ImageAddressUtils imageAddressUtils;
    
        @Test
        public void photoAddressTest() throws ImageProcessingException, IOException {
            System.out.println(imageAddressUtils.getPhotoAddress("C:\\Users\\1\\Desktop\\2023_02_18_20_21_IMG_0057.JPG"));
        }
    
    }

运行结果如图:

![960e06aa08c64f87b9184e8d249754c1.png][]

![048151ea136d401894c7db2973864e13.png][]

[b565f976ea4a46809a4fd70af62bde3e.png]: https://img-blog.csdnimg.cn/img_convert/b565f976ea4a46809a4fd70af62bde3e.png
[960e06aa08c64f87b9184e8d249754c1.png]: https://img-blog.csdnimg.cn/img_convert/960e06aa08c64f87b9184e8d249754c1.png
[048151ea136d401894c7db2973864e13.png]: https://img-blog.csdnimg.cn/img_convert/048151ea136d401894c7db2973864e13.png