c - 图像抖动 : How would I calculate quantization error and nearest colour to implement in a Floyd-Steinburg algorithm?

Question

我打算在嵌入式系统的 1 位显示器上显示(每 channel 4、8 或 16 位 - 无 alpha)图像。图像存储在 RGB 元组中。我的意图是使用 Floyd-Steinburg，因为它看起来相当不错，而且速度足够快且代码简洁。

引用维基百科article ，我有两个问题。

表达最接近的颜色的最佳实践是什么？下面的方法行得通吗？ (忽略我在 c 中返回一个结构)

typedef rgb16_tag { unsigned short r, g, b } rgb16;

rgb16 nearest_1bit_colour(rgb16 p) {
    double c; rgb16 r;
    c  = ((double)(p.r + p.g + p.b + 3 * (1 << 15))) / ( 3.0 * (1 << 16));
    if (c>= 1.0) { 
       r.r = r.g = r.b = 1;
    } else {
       r.r = r.g = r.b = 0;
    }
    return r;
 }

并且，量化误差的表达是基于每个 channel 完成的吗？也就是说，这有意义吗？

rgb16 q, new, old, image[X][Y];
int x, y;

... /* (somewhere in the nested loops) */
    old = image[x][y];
    new = nearest_1bit_colour(old);

    /* Repeat the following for each colour channel seperately. */
    q.{r,g,b} = old.{r,g,b} - new.{r,g,b};

    image[x+1][y].{r,g,b}   = image[x+1][y].{r,g,b} + 7/16 *   q.{r,g,b}
    image[x-1][y+1].{r,g,b} = image[x-1][y+1].{r,g,b} + 3/16 * q.{r,g,b}
    image[x][y+1].{r,g,b}   = image[x][y+1].{r,g,b} + 5/16 *   q.{r,g,b}
    image[x+1][y+1].{r,g,b} = image[x+1][y+1].{r,g,b} + 1/16 * q.{r,g,b}

Answer 1

我见过两种测量两种颜色差异的典型方法。最常见的方法可能就是通过颜色立方体找到它们之间的欧几里得距离:

float r = i.r - j.r;
float g = i.g - j.g;
float b = i.b - j.b;
float diff = sqrtf( r * r + g + g + b * b );

另一种只是平均绝对差异，可能是亮度加权:

float diff = 0.30f * fabs( i.r - j.r ) +
             0.59f * fabs( i.g - j.g ) +
             0.11f * fabs( i.b - j.b );

关于你的第二个问题，是的。在每个 channel 中分别累积误差。

编辑:一开始看错了，错过了这是一个双层显示器。在那种情况下，我建议只使用亮度:

float luminance = 0.30f * p.r + 0.59f * p.g + 0.11f * p.b;
if ( luminance > 0.5f * channelMax ) {
     // white
} else {
     // black
}