java实现图片格式转换(PNG转BMP)

// File: CliOptions.java
package com.example.png2bmp;
 
import org.apache.commons.cli.*;
 
/**
 * 命令行参数解析
 */
public class CliOptions {
    private String inputPath;
    private String outputPath;
    private String bgColor;      // 格式 #RRGGBB
    private boolean keepAlpha;   // true=保留alpha，false=背景合成
    public CliOptions(String[] args) throws ParseException {
        Options opts = new Options();
        opts.addOption("i","input",true,"输入PNG文件或目录路径");
        opts.addOption("o","output",true,"输出BMP文件或目录路径");
        opts.addOption("b","bgcolor",true,"背景色，格式#RRGGBB，默认为#FFFFFF");
        opts.addOption("a","alpha",true,"alpha处理：keep|blend，默认blend");
        opts.addOption("h","help",false,"显示帮助信息");
        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(opts,args);
        if(cmd.hasOption("h")||!cmd.hasOption("i")||!cmd.hasOption("o")){
            new HelpFormatter().printHelp("png2bmp",opts);
            throw new IllegalArgumentException("参数不足");
        }
        inputPath = cmd.getOptionValue("i");
        outputPath = cmd.getOptionValue("o");
        bgColor = cmd.getOptionValue("b","#FFFFFF");
        String alphaOpt = cmd.getOptionValue("a","blend");
        if(!alphaOpt.equals("keep")&&!alphaOpt.equals("blend"))
            throw new IllegalArgumentException("alpha参数仅支持keep或blend");
        keepAlpha = alphaOpt.equals("keep");
    }
    public String getInputPath(){return inputPath;}
    public String getOutputPath(){return outputPath;}
    public String getBgColor(){return bgColor;}
    public boolean isKeepAlpha(){return keepAlpha;}
}
 
// File: PngToBmpConverter.java
package com.example.png2bmp;
 
import javax.imageio.ImageIO;
import java.awt.image.*;
import java.awt.*;
import java.io.*;
import java.util.*;
 
/**
 * 核心转换类：读取PNG并输出BMP
 */
public class PngToBmpConverter {
    private Color bgColor;
    private boolean keepAlpha;
    public PngToBmpConverter(Color bgColor, boolean keepAlpha){
        this.bgColor = bgColor;
        this.keepAlpha = keepAlpha;
    }
 
    /**
     * 转换单个文件
     */
    public void convertFile(File pngFile, File bmpFile) throws IOException {
        BufferedImage src = ImageIO.read(pngFile);
        BufferedImage dst = processImage(src);
        BmpWriter.write(bmpFile, dst, keepAlpha);
    }
 
    /**
     * 批量转换目录下PNG
     */
    public void convertDirectory(File inDir, File outDir) throws IOException {
        if(!outDir.exists()) outDir.mkdirs();
        for(File f:Objects.requireNonNull(inDir.listFiles((d,n)->n.toLowerCase().endsWith(".png")))){
            File out = new File(outDir,f.getName().replaceAll("\\.png$",".bmp"));
            convertFile(f,out);
        }
    }
 
    /**
     * 处理透明度与背景
     */
    private BufferedImage processImage(BufferedImage src){
        int w=src.getWidth(),h=src.getHeight();
        BufferedImage dst;
        if(keepAlpha){
            dst=new BufferedImage(w,h,BufferedImage.TYPE_4BYTE_ABGR);
            for(int y=0;y<h;y++){
                for(int x=0;x<w;x++){
                    int argb=src.getRGB(x,y);
                    dst.setRGB(x,y,argb);
                }
            }
        } else {
            dst=new BufferedImage(w,h,BufferedImage.TYPE_3BYTE_BGR);
            int bgRGB=bgColor.getRGB()&0xFFFFFF;
            for(int y=0;y<h;y++){
                for(int x=0;x<w;x++){
                    int argb=src.getRGB(x,y);
                    int a=(argb>>24)&0xFF;
                    int r=(argb>>16)&0xFF, g=(argb>>8)&0xFF, b=argb&0xFF;
                    float alpha=a/255f;
                    int nr=(int)(r*alpha + ((bgRGB>>16)&0xFF)*(1-alpha));
                    int ng=(int)(g*alpha + ((bgRGB>>8)&0xFF)*(1-alpha));
                    int nb=(int)(b*alpha + (bgRGB&0xFF)*(1-alpha));
                    int rgb=(nr<<16)|(ng<<8)|nb;
                    dst.setRGB(x,y,rgb);
                }
            }
        }
        return dst;
    }
}
 
// File: BmpWriter.java
package com.example.png2bmp;
 
import java.awt.image.*;
import java.io.*;
 
/**
 * 自定义BMP写出工具，支持24位与32位
 */
public class BmpWriter {
 
    /**
     * 写出BMP文件
     */
    public static void write(File outFile, BufferedImage img, boolean argb) throws IOException {
        try (DataOutputStream dos = new DataOutputStream(new FileOutputStream(outFile))) {
            int w=img.getWidth(),h=img.getHeight();
            int bits=argb?32:24;
            int rowBytes = ((w*bits+31)/32)*4;
            int imgSize = rowBytes*h;
            int fileSize = 14+40+imgSize;
 
            // BITMAPFILEHEADER
            dos.writeBytes("BM");
            dos.writeInt(Integer.reverseBytes(fileSize));
            dos.writeShort(Short.reverseBytes((short)0));
            dos.writeShort(Short.reverseBytes((short)0));
            dos.writeInt(Integer.reverseBytes(14+40));
 
            // BITMAPINFOHEADER
            dos.writeInt(Integer.reverseBytes(40));        // header size
            dos.writeInt(Integer.reverseBytes(w));
            dos.writeInt(Integer.reverseBytes(h));
            dos.writeShort(Short.reverseBytes((short)1));  // planes
            dos.writeShort(Short.reverseBytes((short)bits));
            dos.writeInt(0);                               // BI_RGB
            dos.writeInt(Integer.reverseBytes(imgSize));
            dos.writeInt(0);                               // ppm X
            dos.writeInt(0);                               // ppm Y
            dos.writeInt(0);                               // colors
            dos.writeInt(0);                               // important colors
 
            // 像素数据：自下而上，行末对齐填充
            byte[] row = new byte[rowBytes];
            for(int y=h-1;y>=0;y--){
                int idx=0;
                for(int x=0;x<w;x++){
                    int argbVal=img.getRGB(x,y);
                    if(argb){
                        row[idx++]=(byte)(argbVal&0xFF);          // B
                        row[idx++]=(byte)((argbVal>>8)&0xFF);    // G
                        row[idx++]=(byte)((argbVal>>16)&0xFF);   // R
                        row[idx++]=(byte)((argbVal>>24)&0xFF);   // A
                    } else {
                        row[idx++]=(byte)(argbVal&0xFF);
                        row[idx++]=(byte)((argbVal>>8)&0xFF);
                        row[idx++]=(byte)((argbVal>>16)&0xFF);
                    }
                }
                // 填充剩余
                while(idx<rowBytes) row[idx++]=0;
                dos.write(row);
            }
        }
    }
}
 
// File: Main.java
package com.example.png2bmp;
 
import java.awt.Color;
import org.slf4j.*;
 
/**
 * 主入口：解析命令行并执行转换
 */
public class Main {
    private static final Logger logger=LoggerFactory.getLogger(Main.class);
    public static void main(String[] args){
        try {
            CliOptions opts=new CliOptions(args);
            Color bg=Color.decode(opts.getBgColor());
            PngToBmpConverter conv=new PngToBmpConverter(bg,opts.isKeepAlpha());
            java.io.File in=new java.io.File(opts.getInputPath());
            java.io.File out=new java.io.File(opts.getOutputPath());
            if(in.isDirectory()) conv.convertDirectory(in,out);
            else conv.convertFile(in,out);
            logger.info("转换完成");
        } catch(Exception e){
            logger.error("转换失败: {}",e.getMessage());
        }
    }
}
 
// File: PngToBmpTest.java
package com.example.png2bmp;
 
import org.junit.jupiter.api.*;
import java.io.*;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import static org.junit.jupiter.api.Assertions.*;
 
/**
 * 单元测试：验证不同透明策略下PNG->BMP转换结果
 */
public class PngToBmpTest {
    @Test
    void testOpaquePng() throws Exception {
        File png=new File("src/test/resources/test_opaque.png");
        File bmp=new File("build/test_opaque.bmp");
        new PngToBmpConverter(Color.WHITE,false).convertFile(png,bmp);
        BufferedImage img=ImageIO.read(bmp);
        assertEquals(BufferedImage.TYPE_3BYTE_BGR,img.getType());
    }
    @Test
    void testAlphaKeep() throws Exception {
        File png=new File("src/test/resources/test_alpha.png");
        File bmp=new File("build/test_alpha.bmp");
        new PngToBmpConverter(Color.WHITE,true).convertFile(png,bmp);
        BufferedImage img=ImageIO.read(bmp);
        // 由于ImageIO不支持32位BMP,读回时类型可能为INT_ARGB
        assertTrue(img.getColorModel().hasAlpha());
    }
}