JAVA将图片进行高斯模糊

直接上工具类

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.io.*;
import java.util.Arrays;
import java.util.Base64;

public class ImageUtil {
    /**
     * 将图片文件进行模糊
     * @param file
     * @param dir
     * @param saveFileName
     * @return 模糊后的文件
     * @throws IOException
     */
    public static File fileToGaussianBlurFile(File file, String dir, String saveFileName) throws IOException {
        BufferedImage image = decodeToImage(file);
        file.deleteOnExit();
        image = gaussianBlur(image, 8);
        if (!dir.endsWith(File.separator)) {
            dir += File.separator;
        }
        File saveFile = new File(dir + saveFileName);
        encodeToFile(image, saveFile);
        return saveFile;
    }
    /**
     * 将base64进行模糊
     * @param base64
     * @return 模糊后的base64
     */
    public static String base64ToGaussianBlurBase64(String base64) throws Exception {
        return base64GaussianBlur(base64, 10);
    }

    /**
     * 将base64进行模糊
     * @param base64
     * @param dir
     * @param fileName
     * @return 模糊后的文件
     * @throws IOException
     */
    public static File base64ToGaussianBlurFile(String base64, String dir, String fileName) throws IOException {
            // 将base64转图片
            BufferedImage originalImage = decodeBase64ToImage(base64);
            // 将图片进行高斯模糊
            originalImage = gaussianBlur(originalImage, 8);
            if (originalImage.getWidth() > 1000) {
                // 压缩图片
                int width = originalImage.getWidth() / 2;
                int height = originalImage.getHeight() / 2;
                BufferedImage compressedImage = new BufferedImage(width, height, originalImage.getType());
                Graphics2D g2d = compressedImage.createGraphics();
                // 绘制并按比例缩放
                g2d.drawImage(originalImage.getScaledInstance(width, height, Image.SCALE_SMOOTH), 0, 0, null);
                g2d.dispose();
                originalImage = compressedImage;
            }
            // 保存图片到本地文件
            if (!dir.endsWith(File.separator)) {
                dir += File.separator;
            }
            File file = new File(dir + fileName);
            encodeToFile(originalImage, file);
            return file;

    }

    /**
     * 将base64进行高斯模糊
     * @param base64 图片
     * @param blur 模糊度
     * @return
     * @throws Exception
     */
    public static String base64GaussianBlur(String base64, int blur) throws Exception {
        BufferedImage image = decodeBase64ToImage(base64);
        return gaussianBlurReturnBase64(image, blur);
    }
    public static String base64GaussianBlur(File file) throws Exception {
        return base64GaussianBlur(file, 10);
    }
    public static String base64GaussianBlur(File file, int blur) throws Exception {
        BufferedImage image = decodeToImage(file);
        file.deleteOnExit();
        return gaussianBlurReturnBase64(image, blur);
//        return "data:image/png;base64," + imageToGaussianBlur(image, blur);
    }

    /**
     * 进行模糊
     * @param image
     * @param blur 值越大越模糊
     * @return
     */
    private static BufferedImage gaussianBlur(BufferedImage image, int blur) {
        float[] blurKernel = new float[blur * blur];
        Arrays.fill(blurKernel, 1.f /(blur * blur));
        Kernel kernel = new Kernel(blur, blur, blurKernel);
        ConvolveOp op = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
        return op.filter(image, null);
    }

    private static String gaussianBlurReturnBase64(BufferedImage image, int blur) throws Exception {
        return encodeToBase64(gaussianBlur(image, blur));
    }

    private static BufferedImage decodeToImage(File file) throws IOException {
        FileInputStream inputStream = new FileInputStream(file);
        BufferedImage image = ImageIO.read(inputStream);
        inputStream.close();
        return image;
    }

    private static String encodeToBase64(BufferedImage image) throws Exception {
        // 创建字节数组输出流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        // 通过ImageIO写图片
        ImageIO.write(image, "png", bos);
        // 获取图片的byte数组
        byte[] imageBytes = bos.toByteArray();
        // 关闭输出流
        bos.close();
        // 编码成Base64字符串
        return Base64.getEncoder().encodeToString(imageBytes);
    }

    private static boolean encodeToFile(BufferedImage image, File saveFile) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        FileOutputStream os = new FileOutputStream(saveFile);
        try {
            // 通过ImageIO写图片
            ImageIO.write(image, "png", bos);
            // 获取图片的byte数组
            byte[] imageBytes = bos.toByteArray();
            // 关闭输出流
            bos.close();
            os.write(imageBytes);
            return true;
        } finally {
            bos.close();
            os.close();
        }
    }

    private static BufferedImage decodeBase64ToImage(String base64Image) throws IOException {
        // 解码Base64字符串
        byte[] imageBytes = Base64.getDecoder().decode(base64Image);
        // 创建字节数组输入流
        ByteArrayInputStream bis = new ByteArrayInputStream(imageBytes);
        // 通过ImageIO读取图片
        BufferedImage image = ImageIO.read(bis);
        // 关闭输入流
        bis.close();
        return image;
    }