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

骑猪看日落 2022-04-05 12:42 140阅读 0赞

最近在做一个东西，想要将图片压缩后存储到服务器上以节省空间。  
直接使用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();
            }
        }
    }