通过训练将图像压缩到指定大小

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/icarusliu/article/details/84974379

最近在做一个东西，想要将图片压缩后存储到服务器上以节省空间。
直接使用JDK中的类进行压缩处理，但发现压缩后的图片大小跨度区间较大。
最终考虑在计算压缩比例时引入调整值，并对这个调整值进行训练，以尽量缩减压缩后大小与目标大小的差距。
使用不同大小的图片进行训练后就可以得到一组调整值，最终在代码中可以直接使用这组结果来处理。而不是每次都需要重新训练。

实现如下：

package com.irootech.fm.service.impl;

import com.irootech.fm.service.ImageCompressService;
import com.irootech.fm.service.SysConfigService;
import com.sun.image.codec.jpeg.JPEGCodec;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.Optional;

/**
 * 图片压缩工具类
 *
 * @author LiuQI 2018/12/11 19:05
 * @version V1.0
 **/
@Service
public class ImageCompressServiceImpl implements ImageCompressService {
    private static final Logger logger = LoggerFactory.getLogger(ImageCompressServiceImpl.class);
    private static final String FILE_TO_COMPRESS_MIN_SIZE = "fileToCompressMinSize";

    // 压缩经验值训练调整幅度，越小最终效果越好，但所需训练数据也越多
    private static final float TRAIN_EMPIRIC_COMPRESS_RATIO_ADJUST = 0.01f;

    // 压缩经验值保存区间范围；如10000表示10K训练一个调整值；100000表示100K训练一个调整值
    private static final int EMPIRIC_RATIO_SPAN_SIZE = 100000;

    private int fileToCompressMinSize;

    private EmpiricRatioList empiricRatioList = new EmpiricRatioList();

    @Resource
    private SysConfigService configService;

    @PostConstruct
    public void init() {
        this.fileToCompressMinSize = configService.find(FILE_TO_COMPRESS_MIN_SIZE)
                .map(config -> Integer.valueOf(config.getConfigValue())).orElse(512000);
    }

    /**
     * 对图片进行一定范围内的压缩
     */
    @Override
    public InputStream compress(InputStream fileInputStream, String fileName) {
        if (!fileName.endsWith(".jpg")) {
            return fileInputStream;
        }

        try {
            long fileSize = fileInputStream.available();
            if (fileSize <= fileToCompressMinSize) {
                logger.debug("文件小于{}KB，无需压缩", fileToCompressMinSize / 1024);
                return fileInputStream;
            }
            Image image = ImageIO.read(fileInputStream);

            // 先将图片按原比例转换，如果转换后还比指定值大，那么再按比例转换
            float width = ((BufferedImage) image).getWidth();
            float height = ((BufferedImage) image).getHeight();

            BufferedImage destImage = new BufferedImage((int)width, (int)height,
                    BufferedImage.TYPE_INT_RGB);
            destImage.getGraphics().drawImage(image, 0, 0, (int)width, (int)height, null);

            try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
                JPEGCodec.createJPEGEncoder(outputStream).encode(destImage);
                byte[] bytes = outputStream.toByteArray();
                int newFileSize = bytes.length;

                if (newFileSize > fileToCompressMinSize) {
                    // 按比例缩放，并将结果乘以经验值
                    float empiricRatio = getEmpiricRatio(newFileSize);
                    float ratio = (float)fileToCompressMinSize / (float)newFileSize * empiricRatio;
                    width = ratio * width;
                    height = ratio * height;

                    if (logger.isDebugEnabled()) {
                        logger.debug("大小：{}, 压缩比例：{}, 压缩后宽度：{}, 压缩后高度：{}", newFileSize, ratio, width, height);
                    }

                    BufferedImage newDestImage = new BufferedImage((int)width, (int)height, BufferedImage.TYPE_INT_RGB);
                    newDestImage.getGraphics().drawImage(destImage, 0, 0, (int)width, (int)height, null);
                    try (ByteArrayOutputStream newOutputStream = new ByteArrayOutputStream()) {
                        JPEGCodec.createJPEGEncoder(newOutputStream).encode(newDestImage);
                        byte[] newBytes = newOutputStream.toByteArray();

                        // 根据此次的压缩结果训练调整经验值
                        trainEmpiricCompressRatio(newFileSize, newBytes.length, empiricRatio);

                        return new ByteArrayInputStream(newBytes);
                    }
                }

                return new ByteArrayInputStream(bytes);
            }
        } catch (Exception ex) {
            logger.error("尝试对文件压缩失败，未进行压缩", ex);
            return fileInputStream;
        }
    }

    /**
     * 训练压缩率经验值
     */
    private void trainEmpiricCompressRatio(int oldSize, int newSize, float ratio) {
        // 根据原大小所在的区间进行调整
        Optional<EmpiricRatio> findRatio = empiricRatioList.find(oldSize);
        if (findRatio.isPresent()) {
            findRatio.get().setRatio(newSize > fileToCompressMinSize ? ratio - TRAIN_EMPIRIC_COMPRESS_RATIO_ADJUST :
                    (newSize == fileToCompressMinSize ? ratio : ratio + TRAIN_EMPIRIC_COMPRESS_RATIO_ADJUST));
        } else {
            EmpiricRatio empiricRatio = new EmpiricRatio()
                    .setMinSize((oldSize / EMPIRIC_RATIO_SPAN_SIZE) * EMPIRIC_RATIO_SPAN_SIZE)
                    .setRatio(ratio);
            empiricRatioList.add(empiricRatio);
        }
    }

    /**
     * 获取缩放比例的经验值
     */
    private float getEmpiricRatio(int size) {
        return empiricRatioList.find(size).map(EmpiricRatio::getRatio).orElse(1f);
    }

    private class EmpiricRatio {
        private int minSize;
        private float ratio;
        private EmpiricRatio next;
        private EmpiricRatio last;

        int getMinSize() {
            return minSize;
        }

        EmpiricRatio setMinSize(int minSize) {
            this.minSize = minSize;
            return this;
        }

        float getRatio() {
            return ratio;
        }

        EmpiricRatio setRatio(float ratio) {
            this.ratio = ratio;
            return this;
        }

        EmpiricRatio getNext() {
            return next;
        }
    }

    private class EmpiricRatioList {
        private EmpiricRatio header;

        Optional<EmpiricRatio> find(int size) {
            EmpiricRatio pNode = header;
            while (pNode != null) {
                if (size < pNode.getMinSize()) {
                    return Optional.empty();
                } else {
                    if (null == pNode.next) {
                        return Optional.of(pNode);
                    } else if (pNode.next.getMinSize() > size) {
                        return Optional.of(pNode);
                    } else {
                        pNode = pNode.next;
                    }
                }
            }

            return Optional.empty();
        }

        public void add(EmpiricRatio empiricRatio) {
            if (null == header) {
                header = empiricRatio;
            } else {
                EmpiricRatio pNode = header;
                EmpiricRatio lastNode = null;
                while (pNode != null) {
                    if (pNode.getMinSize() >= empiricRatio.getMinSize()) {
                        if (null != pNode.last) {
                            pNode.last.next = empiricRatio;
                        }
                        pNode.last = empiricRatio;
                        empiricRatio.next = pNode;
                        return;
                    }

                    lastNode = pNode;
                    pNode = header.getNext();
                }

                lastNode.next = empiricRatio;
                empiricRatio.last = lastNode;
            }
        }
    }

    // 测试
    public static void main(String[] args) throws IOException {
        ImageCompressServiceImpl compressService = new ImageCompressServiceImpl();
        compressService.fileToCompressMinSize = 512000;

        for (int i = 0; i < 50; i++) {
            InputStream fileInputStream = new FileInputStream(new File("d://image.jpg"));
            InputStream inputStream = compressService.compress(fileInputStream, "image1.jpg");

            OutputStream outputStream = new FileOutputStream("d://temp/image" + (i + 2) + ".jpg");
            byte[] buff = new byte[1000];
            while (-1 != inputStream.read(buff)) {
                outputStream.write(buff);
            }

            inputStream.close();
            outputStream.flush();
            outputStream.close();
        }
    }
}