Question

假设两个ARGB颜色表示为整数，8位/通道（alpha，红色，绿色，蓝色），我需要计算一个代表它们之间的距离（也是整数）的值。

所以距离的公式是：Delta=|R1-R2|+|G1-G2|+|B1-B2|其中Rx，Gx和Bx是颜色1和2的通道的值.Alpha通道总是被忽略。

我需要加快这个计算速度，因为在慢速机器上进行了很多次。在给定两个整数的情况下，在单个线程上计算这个的'geekies'方法是什么。

到目前为止，我最好的是，但我想这可以进一步改善：

    //Used for color conversion from/to int
    private const int ChannelMask = 0xFF;
    private const int GreenShift = 8;
    private const int RedShift = 16;

    public int ComputeColorDelta(int color1, int color2)
    {
        int rDelta = Math.Abs(((color1 >> RedShift) & ChannelMask) - ((color2 >> RedShift) & ChannelMask));
        int gDelta = Math.Abs(((color1 >> GreenShift) & ChannelMask) - ((color2 >> GreenShift) & ChannelMask));
        int bDelta = Math.Abs((color1 & ChannelMask) - (color2 & ChannelMask));

        return rDelta + gDelta + bDelta;
    }

Answer 1

长答案：

多少是“很多”

我想有一台快速的机器，但我写了这个小脚本：

 public static void Main() {
            var s = Stopwatch.StartNew();
            Random r = new Random();
            for (int i = 0; i < 100000000; i++) {
                int compute = ComputeColorDelta(r.Next(255), r.Next(255));
            }
            Console.WriteLine(s.ElapsedMilliseconds);
            Console.ReadLine();
        }

输出是： 6878

所以7亿次1亿次看起来相当不错。

我们可以肯定加快速度。我把你的功能改成了这样：

public static int ComputeColorDelta(int color1, int color2) {
  return 1;
}

随着这一变化，输出为：5546。因此，通过返回常量，我们设法获得超过1亿次迭代的1秒性能增益。 ;）

简短回答：这个功能不是你的瓶颈。：）

Answer 2

我正试图让运行时为我计算。

首先，我使用显式字段偏移

定义struct

[StructLayout(LayoutKind.Explicit)]
public struct Color
{
    [FieldOffset(0)] public int Raw;
    [FieldOffset(0)] public byte Blue;
    [FieldOffset(8)] public byte Green;
    [FieldOffset(16)] public byte Red;
    [FieldOffset(24)] public byte Alpha;
}

计算功能将是：

public int ComputeColorDeltaOptimized(Color color1, Color color2)
{
    int rDelta = Math.Abs(color1.Red - color2.Red);
    int gDelta = Math.Abs(color1.Green - color2.Green);
    int bDelta = Math.Abs(color1.Blue - color2.Blue);

    return rDelta + gDelta + bDelta;
}

用法

public void FactMethodName2()
{
    var s = Stopwatch.StartNew();
    var color1 = new Color(); // This is a structs, so I can define they out of loop and gain some performance
    var color2 = new Color(); 
    for (int i = 0; i < 100000000; i++)
    {
        color1.Raw = i;
        color2.Raw = 100000000 - i;
        int compute = ComputeColorDeltaOptimized(color1, color2);
    }
    Console.WriteLine(s.ElapsedMilliseconds); //5393 vs 7472 of original 
    Console.ReadLine();
}

Answer 3

一个想法是使用您已有的相同代码，但顺序不同：应用蒙版，取差异，然后移动。

另一个可能有帮助的修改是内联这个函数：也就是说，不是为每对颜色调用它，而是直接计算差异，在任何循环中执行此代码。我认为它是在一个紧密的循环中，因为否则它的成本可以忽略不计。

最后，由于您可能正在获取图像像素数据，因此您可以通过unsafe路径节省大量资金：制作像EditableBitmap这样的位图，然后抓取字节*并读取图像数据。

Answer 4

您可以执行此操作以减少AND操作：

public int ComputeColorDelta(int color1, int color2)
{
    int rDelta = Math.Abs((((color1  >> RedShift) - (color2  >> RedShift))) & ChannelMask)));
    // same for other color channels

    return rDelta + gDelta + bDelta;
}

不多但是......

如何加快这个计算

4 个答案: