卷积滤波器 - Float Precision C 与 Java

Question

我正在将图像处理例程库从 Java 移植到 C 中，当我比较结果时，我发现了一些非常小的差异。 这些差异存在于不同语言对浮点值的处理中是否合理，或者我还有工作要做！

该例程是具有 3 x 3 内核的卷积，它在由像素、宽度和深度的线性数组表示的位图上进行操作。 您不需要完全理解这段代码来回答我的问题，它只是供参考。

Java代码；

for (int x = 0; x < width; x++){
            for (int y = 0; y < height; y++){
                int offset = (y*width)+x;
                if(x % (width-1) == 0 || y % (height-1) == 0){
                    input.setPixel(x, y, 0xFF000000); // Alpha channel only for border
                } else {
                    float r = 0;
                    float g = 0;
                    float b = 0;
                    for(int kx = -1 ; kx <= 1; kx++ ){
                        for(int ky = -1 ; ky <= 1; ky++ ){
                            int pixel = pix[offset+(width*ky)+kx];
                            int t1 = Color.red(pixel);
                            int t2 = Color.green(pixel);
                            int t3 = Color.blue(pixel);

                            float m = kernel[((ky+1)*3)+kx+1];

                            r += Color.red(pixel) * m;
                            g += Color.green(pixel) * m;
                            b += Color.blue(pixel) * m;                     
                        }
                    }
                    input.setPixel(x, y, Color.rgb(clamp((int)r), clamp((int)g), clamp((int)b)));
                }
            }
        }
        return input; 

Clamp 将波段值限制在 [0..255] 范围内，并且 Color.red 相当于 (pixel & 0x00FF0000) >>> 16.

C 代码是这样的；

for(x=1;x<width-1;x++){
        for(y=1; y<height-1; y++){
            offset = x + (y*width);
            rAcc=0;
            gAcc=0;
            bAcc=0;
            for(z=0;z<kernelLength;z++){
                xk = x + xOffsets[z];
                yk = y + yOffsets[z];
                kOffset = xk + (yk * width);

                rAcc += kernel[z] * ((b1[kOffset] & rMask)>>16);
                gAcc += kernel[z] * ((b1[kOffset] & gMask)>>8);
                bAcc += kernel[z] * (b1[kOffset] & bMask);
            }

            // Clamp values
            rAcc = rAcc > 255 ? 255 : rAcc < 0 ? 0 : rAcc;
            gAcc = gAcc > 255 ? 255 : gAcc < 0 ? 0 : gAcc;
            bAcc = bAcc > 255 ? 255 : bAcc < 0 ? 0 : bAcc;


            // Round the floats
                    r = (int)(rAcc + 0.5);
            g = (int)(gAcc + 0.5);
            b = (int)(bAcc + 0.5);

            output[offset] = (a|r<<16|g<<8|b) ;
        }
    }

它有点不同，例如 xOffsets 为内核元素提供 xOffset。

重点是我的结果最多相差一位。 以下是像素值；

FF205448 expected
FF215449 returned
44 wrong
FF56977E expected
FF56977F returned
45 wrong
FF4A9A7D expected
FF4B9B7E returned
54 wrong
FF3F9478 expected
FF3F9578 returned
74 wrong
FF004A12 expected
FF004A13 returned

您认为这是我的代码的问题还是语言的差异？

亲切的问候，

加夫

Answer 1

快速浏览一下后：

您是否意识到 (int)r 会将 r 值取整而不是正常舍入？
在c代码中，你似乎使用 (int)(r + 0.5)

Answer 2

除了 Fortega 的答案，请尝试 roundf() C 数学库中的函数。

Answer 3

Java 的浮点行为非常精确。 我期望这里发生的是，该值以扩展精度保存在寄存器中。 IIRC，Java 要求精度四舍五入到适当类型的精度。 这是为了确保您始终获得相同的结果（JLS 中的完整详细信息）。 C 编译器往往会保留任何额外的精度，直到结果存储到主内存中。

Answer 4

我建议你使用 double 而不是 float。 浮动几乎从来都不是最好的选择。

Answer 5

这可能是由于两种语言的默认轮数不同所致。 我并不是说他们有（你需要阅读才能确定），但这是一个想法。