Изображение / “большая часть пиксельной оптимизации поиска” сходства?

Ситуация:

Скажем, я имею изображение, скажем, 512x512 пикселей и отображаю B, 5x5 или 7x7 пикселей. Оба изображения составляют 24 бита rgb, и B имеют альфа-маску на 1 бит (таким образом, каждый пиксель или абсолютно прозрачен или абсолютно тверд).

Я должен найти в рамках изображения пиксель, который (с соседями it) наиболее тесно напоминает изображение B, Орегон пиксель, который, вероятно, наиболее тесно напоминает изображение B.

Подобие вычисляется как "расстояние", которое является суммой "расстояний" между непрозрачными пикселями B и пикселями A, разделенными на число непрозрачных пикселей B. Вот демонстрационный код SDL для объяснения:

struct Pixel{
    unsigned char b, g, r, a;
};

void fillPixel(int x, int y, SDL_Surface* dst, SDL_Surface* src, int dstMaskX, int dstMaskY){
    Pixel& dstPix = *((Pixel*)((char*)(dst->pixels) + sizeof(Pixel)*x + dst->pitch*y));

    int xMin = x + texWidth - searchWidth;
    int xMax = xMin + searchWidth*2;
    int yMin = y + texHeight - searchHeight;
    int yMax = yMin + searchHeight*2;


    int numFilled = 0;
    for (int curY = yMin; curY < yMax; curY++)
        for (int curX = xMin; curX < xMax; curX++){
            Pixel& cur = *((Pixel*)((char*)(dst->pixels) + sizeof(Pixel)*(curX & texMaskX) + dst->pitch*(curY & texMaskY)));
            if (cur.a != 0)
                numFilled++;
        }

    if (numFilled == 0){
        int srcX = rand() % src->w;
        int srcY = rand() % src->h;
        dstPix = *((Pixel*)((char*)(src->pixels) + sizeof(Pixel)*srcX + src->pitch*srcY));
        dstPix.a = 0xFF;
        return;
    }

    int storedSrcX = rand() % src->w;
    int storedSrcY = rand() % src->h;
    float lastDifference = 3.40282347e+37F;

    //unsigned char mask = 

    for (int srcY = searchHeight; srcY < (src->h - searchHeight); srcY++)
        for (int srcX = searchWidth; srcX < (src->w - searchWidth); srcX++){
            float curDifference = 0;
            int numPixels = 0;
            for (int tmpY = -searchHeight; tmpY < searchHeight; tmpY++)
                for(int tmpX = -searchWidth; tmpX < searchWidth; tmpX++){
                    Pixel& tmpSrc = *((Pixel*)((char*)(src->pixels) + sizeof(Pixel)*(srcX+tmpX) + src->pitch*(srcY+tmpY)));
                    Pixel& tmpDst = *((Pixel*)((char*)(dst->pixels) + sizeof(Pixel)*((x + dst->w + tmpX) & dstMaskX) + dst->pitch*((y + dst->h + tmpY) & dstMaskY)));
                    if (tmpDst.a){
                        numPixels++;
                        int dr = tmpSrc.r - tmpDst.r;
                        int dg = tmpSrc.g - tmpDst.g;
                        int db = tmpSrc.g - tmpDst.g;
                        curDifference += dr*dr + dg*dg + db*db;
                    }
                }
            if (numPixels)
                curDifference /= (float)numPixels;
            if (curDifference < lastDifference){
                lastDifference = curDifference;
                storedSrcX = srcX;
                storedSrcY = srcY;
            }
        }

    dstPix = *((Pixel*)((char*)(src->pixels) + sizeof(Pixel)*storedSrcX + src->pitch*storedSrcY));
    dstPix.a = 0xFF;
}

Эта вещь, как предполагается, используется для поколения структуры.

Теперь, вопрос:
Самый легкий способ сделать это - поиск грубой силы (который используется в стандартной программе в качестве примера). Но это медленно - даже использование ускорения GPU и двухъядерного CPU не сделает его намного быстрее. Похоже, что я не могу использовать измененный двоичный поиск из-за маски B. Так, как я могу найти желаемый пиксель быстрее?

Дополнительная информация:

1. Позволяется использовать 2 ядра, ускорение GPU, CUDA, и 1.5.. 2 гигабайта RAM для задачи.
2. Я предпочел бы избегать некоторой длинной фазы предварительной обработки, которая займет 30 минут для окончания.

Идеи?