BufferedImage src = ImageIO.read(new File(srcPath));

float[] lap = {0,-1,0, -1,5,-1, 0,-1,0};
Kernel kernel = new Kernel(3,3,lap);
ConvolveOp op = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
BufferedImage sharp = op.filter(src, null);

// 1. Gaussian Blur
float[] gauss = createGaussianKernel(radius);
Kernel gk = new Kernel(k, k, gauss);
BufferedImage blurred = new ConvolveOp(gk).filter(src, null);
// 2. 差值并增強
for each pixel:
  int orig = src.getRGB(x,y);
  int b = blurred.getRGB(x,y);
  int diff = orig - b;
  int result = clamp(orig + amount * diff);

ImageWriter writer = ImageIO.getImageWritersByFormatName("jpg").next();
ImageWriteParam param = writer.getDefaultWriteParam();
param.setCompressionMode(MODE_EXPLICIT);
param.setCompressionQuality(q);
writer.write(null,new IIOImage(sharp,null,null),param);

import java.awt.image.*;
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
import javax.imageio.*;
import javax.imageio.stream.ImageOutputStream;
 
/**
 * ImageSharpenUtil：圖像銳化工具
 */
public class ImageSharpenUtil {
    // 默認參數(shù)
    private static final double UNSHARP_AMOUNT = 1.0;   // 反銳化掩模強度
    private static final int GAUSS_RADIUS = 3;         // Gaussian 模糊半徑
    private static final float JPEG_QUALITY = 0.9f;    // JPEG 輸出質(zhì)量
    private static final int THREADS = Runtime.getRuntime().availableProcessors();
 
    public static void main(String[] args) throws Exception {
        if (args.length < 2) {
            System.out.println("用法: java ImageSharpenUtil <src> <dest> [laplacian|unsharp]");
            return;
        }
        Path src = Paths.get(args[0]), dest = Paths.get(args[1]);
        String mode = args.length >= 3 ? args[2] : "laplacian";
        if (Files.isDirectory(src)) {
            batchProcess(src, dest, mode);
        } else {
            processSingle(src.toFile(), dest.toFile(), mode);
        }
        System.out.println("完成。");
    }
 
    // 單圖處理
    public static void processSingle(File in, File out, String mode) throws IOException {
        BufferedImage src = ImageIO.read(in);
        if (src == null) throw new IOException("無法讀取: " + in);
        BufferedImage result = "unsharp".equals(mode)
            ? unsharpMask(src, GAUSS_RADIUS, UNSHARP_AMOUNT)
            : laplacianSharpen(src);
        writeImage(result, out);
        System.out.println("處理: " + in);
    }
 
    // 批量處理
    public static void batchProcess(Path srcDir, Path destDir, String mode) throws IOException, InterruptedException {
        List<Path> list = new ArrayList<>();
        try (Stream<Path> s = Files.walk(srcDir)) {
            s.filter(Files::isRegularFile)
             .filter(p->p.toString().matches(".*\\.(?i)(png|jpe?g|bmp|gif)$"))
             .forEach(list::add);
        }
        ExecutorService exec = Executors.newFixedThreadPool(THREADS);
        for (Path p : list) {
            exec.submit(() -> {
                try {
                    Path rel = srcDir.relativize(p);
                    File out = destDir.resolve(rel).toFile();
                    out.getParentFile().mkdirs();
                    processSingle(p.toFile(), out, mode);
                } catch (Exception e) {
                    System.err.println("失敗: " + p + " " + e.getMessage());
                }
            });
        }
        exec.shutdown();
        exec.awaitTermination(1, TimeUnit.HOURS);
    }
 
    // 拉普拉斯銳化
    public static BufferedImage laplacianSharpen(BufferedImage src) {
        float[] lap = {0,-1,0, -1,5,-1, 0,-1,0};
        Kernel kernel = new Kernel(3,3,lap);
        return new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null).filter(src, null);
    }
 
    // 反銳化掩模
    public static BufferedImage unsharpMask(BufferedImage src, int radius, double amount) {
        int size = radius * 2 + 1;
        float[] matrix = createGaussianKernel(radius);
        Kernel gk = new Kernel(size, size, matrix);
        BufferedImage blurred = new ConvolveOp(gk, ConvolveOp.EDGE_NO_OP, null).filter(src, null);
        BufferedImage dest = new BufferedImage(src.getWidth(), src.getHeight(), src.getType());
        for (int y=0; y<src.getHeight(); y++){
            for (int x=0; x<src.getWidth(); x++){
                int rgb1 = src.getRGB(x,y), rgb2 = blurred.getRGB(x,y);
                int a = (rgb1>>24)&0xFF;
                int r = clamp(((rgb1>>16&0xFF) - (rgb2>>16&0xFF)) * amount + (rgb1>>16&0xFF));
                int g = clamp(((rgb1>>8&0xFF) - (rgb2>>8&0xFF)) * amount + (rgb1>>8&0xFF));
                int b = clamp(((rgb1&0xFF) - (rgb2&0xFF)) * amount + (rgb1&0xFF));
                dest.setRGB(x,y, (a<<24)|(r<<16)|(g<<8)|b );
            }
        }
        return dest;
    }
 
    // 生成 Gaussian 核
    private static float[] createGaussianKernel(int radius) {
        int size = radius*2+1;
        float[] data = new float[size*size];
        double sigma = radius/3.0;
        double twoSigmaSq = 2*sigma*sigma;
        double piSigma = Math.PI * twoSigmaSq;
        double sum = 0;
        for(int y=-radius; y<=radius; y++){
            for(int x=-radius; x<=radius; x++){
                double v = Math.exp(-(x*x+y*y)/twoSigmaSq)/piSigma;
                data[(y+radius)*size + (x+radius)] = (float)v;
                sum += v;
            }
        }
        for(int i=0;i<data.length;i++) data[i] /= sum;
        return data;
    }
 
    // 寫出圖片
    public static void writeImage(BufferedImage img, File out) throws IOException {
        String ext = getExt(out.getName());
        out.getParentFile().mkdirs();
        if ("jpg".equalsIgnoreCase(ext)||"jpeg".equalsIgnoreCase(ext)) {
            Iterator<ImageWriter> it = ImageIO.getImageWritersByFormatName("jpg");
            ImageWriter w = it.next();
            try (ImageOutputStream ios = ImageIO.createImageOutputStream(out)) {
                w.setOutput(ios);
                ImageWriteParam p = w.getDefaultWriteParam();
                if (p.canWriteCompressed()) {
                    p.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
                    p.setCompressionQuality(JPEG_QUALITY);
                }
                w.write(null, new IIOImage(img,null,null),p);
            } finally { w.dispose(); }
        } else {
            ImageIO.write(img, ext, out);
        }
    }
 
    private static int clamp(double v) {
        return v<0?0:(v>255?255:(int)v);
    }
    private static String getExt(String name) {
        int i=name.lastIndexOf('.'); return i<0?"png":name.substring(i+1);
    }
}