Java实现Floyd-Steinberg抖动算法输出异常Bug求解

你的代码输出异常核心不是舍入逻辑，是对算法实现逻辑存在多处根本性错误，具体问题如下：

1. 误差计算逻辑完全错误 #

你当前调用calculateErr时，传入的是打包后的完整RGB整数值pixelValue和量化后的newPixel直接做差。打包后的RGB值是按AARRGGBB位格式存储的整数，直接相减得到的不是单通道亮度误差，是三个通道值移位叠加后的无意义整数，按比例扩散后完全不符合算法要求。

正确逻辑：误差需要逐通道单独计算，红、绿、蓝三个通道分别计算原始值和量化后新值的差，再将对应通道的误差按比例扩散到邻域像素的对应通道上，禁止直接对打包后的整像素值做差。

2. 误差传播逻辑完全不符合算法要求 #

Floyd-Steinberg算法的核心是：当前像素量化产生的误差，要叠加到尚未处理的邻域像素的原始值上，后续处理邻域像素时，使用叠加了误差的数值做量化。你当前的实现是直接把误差值写入输出图ditheredIMG，完全没有修改待处理的源图像像素，误差根本没有参与后续像素的量化计算，自然无法生成正确的抖动效果。

3. 图像类型、遍历边界、坐标偏移均存在错误 #

• 你将输出图ditheredIMG定义为TYPE_BYTE_GRAY灰度图类型，但写入时传入的是RGB三通道打包值，灰度图无法正确存储三通道彩色信息；
• 遍历时从x=1、y=1开始，到宽高-1结束，图像最边缘一圈像素完全未处理，会出现黑边；
• 写入误差时坐标偏移逻辑错误：扩散邻域的坐标是待处理源图像上的像素坐标，不是输出图的偏移坐标，你当前给x坐标加1写入输出图，直接导致像素位置完全错位。

4. 缺少数值截断和合理的取整逻辑 #

• 误差叠加到邻域像素后，通道值可能超出0-255的合法范围，你没有做截断处理，会出现颜色溢出异常；
• 直接将浮点计算结果强转成int时，Java会直接截断小数部分，而非四舍五入，容易造成误差累积偏差，可通过整数运算或加0.5后取整规避该问题。

修正后核心实现参考 #

重写getPixels方法，新增通道值截断方法，核心逻辑是先创建源图的可修改工作副本，逐像素逐通道计算量化误差，将误差叠加到工作副本的邻域像素上，处理完当前像素后直接将量化结果写入输出图：

// 通道值截断方法，保证值始终在0-255合法区间
private int clamp(int val) {
    return Math.max(0, Math.min(255, val));
}

public void getPixels(Graphics g, BufferedImage i) {
    // 创建源图的可修改工作副本，用于存储叠加误差后的像素值
    BufferedImage workImg = new BufferedImage(i.getWidth(), i.getHeight(), BufferedImage.TYPE_INT_RGB);
    workImg.getGraphics().drawImage(i, 0, 0, null);
    // 初始化输出图为彩色类型，和输入格式匹配
    ditheredIMG = new BufferedImage(i.getWidth(), i.getHeight(), BufferedImage.TYPE_INT_RGB);

    for (int y = 0; y < workImg.getHeight(); y++){
        for (int x = 0; x < workImg.getWidth(); x++) {
            int pixelValue = workImg.getRGB(x, y);
            // 拆分三通道值
            int red   = (pixelValue & 0x00ff0000) >> 16;
            int green = (pixelValue & 0x0000ff00) >> 8;
            int blue  =  pixelValue & 0x000000ff;
            // 逐通道量化
            int newRed = quantisePixel(red);
            int newGreen = quantisePixel(green);
            int newBlue = quantisePixel(blue);
            // 将量化后的像素写入输出图
            int newPixel = (0xFF << 24) | (newRed << 16) | (newGreen << 8) | newBlue;
            ditheredIMG.setRGB(x,y, newPixel);

            // 逐通道计算量化误差
            int errR = red - newRed;
            int errG = green - newGreen;
            int errB = blue - newBlue;

            // 按Floyd-Steinberg系数将误差扩散到邻域像素，先判断边界避免数组越界
            // 右侧像素 系数7/16
            if (x+1 < workImg.getWidth()) {
                int p = workImg.getRGB(x+1, y);
                int r = clamp(((p>>16)&0xFF) + errR * 7 /16);
                int g = clamp(((p>>8)&0xFF) + errG *7/16);
                int b = clamp((p&0xFF) + errB*7/16);
                workImg.setRGB(x+1, y, (0xFF<<24)|(r<<16)|(g<<8)|b);
            }
            // 左下像素 系数3/16
            if (x-1 >=0 && y+1 < workImg.getHeight()) {
                int p = workImg.getRGB(x-1, y+1);
                int r = clamp(((p>>16)&0xFF) + errR *3/16);
                int g = clamp(((p>>8)&0xFF) + errG *3/16);
                int b = clamp((p&0xFF) + errB*3/16);
                workImg.setRGB(x-1, y+1, (0xFF<<24)|(r<<16)|(g<<8)|b);
            }
            // 正下像素 系数5/16
            if (y+1 < workImg.getHeight()) {
                int p = workImg.getRGB(x, y+1);
                int r = clamp(((p>>16)&0xFF) + errR *5/16);
                int g = clamp(((p>>8)&0xFF) + errG *5/16);
                int b = clamp((p&0xFF) + errB*5/16);
                workImg.setRGB(x, y+1, (0xFF<<24)|(r<<16)|(g<<8)|b);
            }
            // 右下像素 系数1/16
            if (x+1 < workImg.getWidth() && y+1 < workImg.getHeight()) {
                int p = workImg.getRGB(x+1, y+1);
                int r = clamp(((p>>16)&0xFF) + errR *1/16);
                int g = clamp(((p>>8)&0xFF) + errG *1/16);
                int b = clamp((p&0xFF) + errB*1/16);
                workImg.setRGB(x+1, y+1, (0xFF<<24)|(r<<16)|(g<<8)|b);
            }
        }
    }
}

补充说明 #

如果需要输出灰度抖动效果，可先将原图转为灰度图，仅对亮度单通道做上述量化和误差扩散逻辑即可，无需拆分三个RGB通道。 #

内容的提问来源于stack exchange，提问作者Ben_forde