使用CIfilter的误差扩散抖动图像

我正在尝试抖动图像。我编写了一些快速代码，这些代码应用了floyd steinberg抖动，但是处理图像的时间很长，因为它没有包装在cifilter中，它只是快速代码。我在想，如果我可以创建自定义cifilter，它将在gpu上进行处理并加快处理速度。但是我不是CIfilter语言专家。

这是我的快速代码。为了清楚起见，我已将错误分布矩阵的计算完整写出。

internal struct color {
let r: Int
let g: Int
let b: Int
}
func ditherImage2(){
let image = UIImage(named: "image")
let width = Int(image!.size.width)
let height = Int(image!.size.height)
let pixelArray = pixelarray(image)
func offset(row: Int,column: Int) -> Int {
return row * width + column
}
for y in 0 .. for x in 0 .. let currentOffset = offset(row: y,column: x)
let currentColor = pixelArray![currentOffset]
// get current colour of pixel
let oldR = currentColor.r
let oldG = currentColor.g
let oldB = currentColor.b
// quantize / reduce the colours to pallet of 6 colours
let factor = 1;
let newR = round(factor * oldR / 255) * (255/factor)
let newG = round(factor * oldG / 255) * (255/factor)
let newB = round(factor * oldB / 255) * (255/factor)
pixelArray[currentOffset] = color(r:newR,g:newG,b:newB)
let errR = oldR - newR;
let errG = oldG - newG;
let errB = oldB - newB;
// distribute the error to the surrounding pixels using floyd stenberg matrix
let index = offset(row:x+1,column:y)
let c = pixelArray[index]
let r = c.r
let g = c.g
let b = c.b
r = r + errR * 7/16.0;
g = g + errG * 7/16.0;
b = b + errB * 7/16.0;
pixelArray[index] = color(r:r,g:g,b:b);
let index2 = offset(row:x-1,column:y+1 );
let c2 = pixelArray[index2]
let r2 = c.r
let g2 = c.g
let b2 = c.b
r2 = r2 + errR * 3/16.0;
g2 = g2 + errG * 3/16.0;
b2 = b2 + errB * 3/16.0;
pixelArray[index] = color(r:r2,g:g2,b:b2);
let index3 = offset(row:x,column:y+1);
let c3 = pixelArray[index3]
let r3 = c.r
let g3 = c.g
let b3 = c.b
r3 = r3 + errR * 5/16.0;
g3 = g3 + errG * 5/16.0;
b3 = b3 + errB * 5/16.0;
pixelArray[index] = color(r:r3,g:g3,b:b3);
let index4 = offset(row:x+1,column:y+1);
let c4 = pixelArray[index]
let r4 = c.r
let g4 = c.g
let b4 = c.b
r4 = r4 + errR * 1/16.0;
g4 = g4 + errG * 1/16.0;
b4 = b4 + errB * 1/16.0;
pixelArray[index] = color(r:r4,g:g4,b:b4);
}
}
}


我发现这个https://github.com/rhoeper/Filterpedia-Swift4包括一个用于有序抖动的自定义过滤器，我可以将其用作基础并尝试适应误差扩散抖动。我希望找到一个现有的自定义内核，该内核可以在开始学习CIfilter语言之前就可以完成工作。因此，我想知道是否有人拥有现有内核或指向该内核的链接？

有序抖动代码

1. float orderedDither2x2(float colorin,float bx,float by,float errorIntensity)
{
float error = 0.0;
int px = int(bx);
int py = int(by);
if (py == 0) {
if (px == 0) { error = 1.0 / 4.0; }
if (px == 1) { error = 3.0 / 4.0; }
}
if (py == 1) {
if (px == 0) { error = 4.0 / 4.0; }
if (px == 1) { error = 2.0 / 4.0; }
}
return colorin * (error * errorIntensity);
}
kernel vec4 ditherBayer(sampler image,float intensity,float matrix,float palette)
{
vec4 pixel = sample(image,samplerCoord(image));
int msize = int(matrix);
float px = mod(pixel.x,msize >= 5 ? float(4.0) : float(msize));
float py = mod(pixel.y,msize >= 5 ? float(4.0) : float(msize));
float red = pixel.r;
float green = pixel.g;
float blue = pixel.b;
if (msize == 2) {
pixel.r = orderedDither2x2(red,px,py,intensity);
pixel.g = orderedDither2x2(green,intensity);
pixel.b = orderedDither2x2(blue,intensity);
}
if (msize == 3) {
pixel.r = orderedDither3x3(red,intensity);
pixel.g = orderedDither3x3(green,intensity);
pixel.b = orderedDither3x3(blue,intensity);
}
if (msize == 4) {
pixel.r = orderedDither4x4(red,intensity);
pixel.g = orderedDither4x4(green,intensity);
pixel.b = orderedDither4x4(blue,intensity);
}
if (msize >= 5) {
pixel.r = orderedDither8x8(red,intensity);
pixel.g = orderedDither8x8(green,intensity);
pixel.b = orderedDither8x8(blue,intensity);
}
if (int(palette) == 0) { return vec4(binary(vec3(pixel.r,pixel.g,pixel.b)),pixel.a); }
if (int(palette) == 1) { return vec4(commodore64(vec3(pixel.r,pixel.a); }
if (int(palette) == 2) { return vec4(vic20(vec3(pixel.r,pixel.a); }
if (int(palette) == 3) { return vec4(appleII(vec3(pixel.r,pixel.a); }
if (int(palette) == 4) { return vec4(zxSpectrumBright(vec3(pixel.r,pixel.a); }
if (int(palette) == 5) { return vec4(zxSpectrumDim(vec3(pixel.r,pixel.a); }
return pixel;
}


弗洛伊德-斯坦伯格（Floyd-Steinberg）抖动的问题在于，它是一种串行算法-结果像素的颜色值取决于先前计算的像素。核心映像（以及任何类型的SIMD并行化技术）不适用于此类问题。它们旨在在所有像素上同时执行相同的任务。

但是，我找到了一些方法来部分并行化独立像素on the GPU甚至是有趣的CPU-GPU-hybrid approach的计算。

不幸的是，由于CIFilters在可利用的GPU资源方面受到限制（例如，无法访问全局内存），因此Core Image可能不是实现这些技术的最佳框架。您可以直接使用Metal计算着色器（而不是通过Core Image），但这将需要更多的支持代码。

如果您不一定需要进行错误扩散，则仍可以使用有序抖动（可以高度并行化）来获得类似的结果。我还发现了一个nice article。内置的CIDither过滤器也可能使用这种方法。