2019-12-09 springboot 多张png图片合成g

需要引入的依赖

    <!-- GIF依赖-->
        <dependency>
            <groupId>com.madgag</groupId>
            <artifactId>animated-gif-lib</artifactId>
            <version>1.4</version>
        </dependency>

包装成工具类

public class GIFUtil {

    private static Logger logger = LoggerFactory.getLogger(GIFUtil.class);

    public static void png2Gif(String filePath) {
        // String filePath = "需要生成GIF的图片素材目录";
        // filePath = "E:\\文档\\hxlc\\satelite\\pic\\VIS";
        File[] files = getFiles(filePath);
        //如果isPressed设置为true会对Gif图片进行压缩处理
        File preview = generatePreview(files, true);
        try {
            preview.createNewFile();
            logger.info("文件大小是：{}", preview.length() / 1024 + "KB");
            // logger.info(DigestUtils.md5Hex(new FileInputStream(preview)));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成GIF图片
     *
     * @param files     原始PNG图片
     * @param isPressed 是否被压缩，默认true
     * @return
     */
    public static File generatePreview(File[] files, Boolean isPressed) {
        Path path = null;
        try {
            path = Files.createTempFile(Paths.get("F:\\gifile\\"), "preview_", ".gif");
            logger.info("文件下载路径:{}", path);

            BufferedImage[] images = null;
            if (isPressed) {
                images = parseCompressed(files);
            } else {
                images = parse(files);
            }
            AnimatedGifEncoder encoder = new AnimatedGifEncoder();
            // 设置循环模式，0为无限循环 这里没有使用源文件的播放次数
            encoder.setRepeat(0);
            encoder.start(new FileOutputStream(path.toFile()));
            int count = 1;
            //采样频率，数字越大，文件越小，丢失的帧越多，设置为1可保持原帧
            int frequency = 2;
            for (BufferedImage image : images) {
                if ((++count) % frequency == 0) {
                    encoder.setDelay(100 * frequency);
                    encoder.addFrame(image);
                }
            }
            encoder.finish();
            logger.info("GIF创建成功...");
        } catch (IOException e) {
            logger.error("failed to generate preview file...{}", e.getLocalizedMessage());
        }
        return path.toFile();
    }

    /**
     * 把PNG素材压缩并转成BufferedImage
     *
     * @param files png文件
     * @return BufferedImage[]
     */
    private static BufferedImage[] parseCompressed(File[] files) {
        BufferedImage[] bi = new BufferedImage[files.length];
        int biIndex = 0;
        try {
            for (int index = 0; index < files.length; index++) {
                //过滤掉压缩可能产生的空值
                if (compressPic(ImageIO.read(files[index])) == null) {
                    continue;
                }
                bi[biIndex++] = compressPic(ImageIO.read(files[index]));
            }
        } catch (IOException e) {
            logger.error("fail to parse compressed template...{}", e.getLocalizedMessage());
        }
        return Arrays.copyOfRange(bi, 0, biIndex);
    }

    /**
     * 把PNG素材原图转成BufferedImage
     *
     * @param files png文件
     * @return BufferedImage[]
     */
    private static BufferedImage[] parse(File[] files) {
        BufferedImage[] bi = new BufferedImage[files.length];
        try {
            for (int index = 0; index < files.length; index++) {
                bi[index] = ImageIO.read(files[index]);
            }
        } catch (IOException e) {
            logger.error("fail to parse template...{}", e.getLocalizedMessage());
        }
        return bi;
    }

    /**
     * proportion：是否等比缩放标记(默认为等比缩放)
     * outputWidth：默认输出图片宽
     * outputHeight：默认输出图片高
     */
    private static boolean proportion = true;
    private static int outputWidth = 1800;
    private static int outputHeight = 1200;

    /**
     * 对图片进行压缩处理
     *
     * @param img
     * @return
     */
    public static BufferedImage compressPic(BufferedImage img) {
        BufferedImage imgCompressed = null;
        try {
            if (img.getWidth(null) == -1) {
                //打印错误日志
                System.out.println("图片格式错误！");
                return imgCompressed;
            } else {
                int newWidth;
                int newHeight;
                // 判断是否是等比缩放
                if (proportion == true) {
                    // 为等比缩放计算输出的图片宽度及高度
                    double rate1 = ((double) img.getWidth(null)) / (double) outputWidth * 1.0;
                    double rate2 = ((double) img.getHeight(null)) / (double) outputHeight * 1.0;
                    // 根据缩放比率大的进行缩放控制
                    double rate = rate1 > rate2 ? rate1 : rate2;
                    newWidth = (int) (((double) img.getWidth(null)) / rate);
                    newHeight = (int) (((double) img.getHeight(null)) / rate);
                } else {
                    // 输出的图片宽度
                    newWidth = outputWidth;
                    // 输出的图片高度
                    newHeight = outputHeight;
                }
                imgCompressed = new BufferedImage((int) newWidth, (int) newHeight, BufferedImage.TYPE_INT_RGB);
                /*
                 * Image.SCALE_SMOOTH 的缩略算法 生成缩略图片的平滑度的优先级比速度高 生成的图片质量比较好 但速度慢
                 */
                imgCompressed.getGraphics().drawImage(img.getScaledInstance(newWidth, newHeight, Image.SCALE_SMOOTH), 0, 0, null);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return imgCompressed;
    }

    public static File[] getFiles(String path) {
        File file = new File(path);
        File[] files = file.listFiles();
        return files;
    }
}

图片列表