Найшвидший алгоритм дистанційної трансформації

Я шукаю найшвидший доступний алгоритм дистанційного перетворення.

За даними цього сайту http://homepages.inf.ed.ac.uk/rbf/HIPR2/distance.htm , він описує:

Перетворення відстані можна обчислити набагато ефективніше, використовуючи розумні алгоритми лише за два проходи (наприклад, Розенфельд і Пфальц 1968).

Шукаючи навколо, я виявив: "Розенфельд, А і Пфальц, Дж. Л. 1968. Функції відстані на цифрових картинках. Розпізнавання візерунків, 1, 33-61."

Але я вважаю, що у нас повинен бути кращий і швидший алгоритм, ніж у 1968 році? Насправді я не зміг знайти джерело з 1968 року, тому будь-яка допомога високо цінується.

Педро Ф. Фельценсвальб та Даніель П. Гуттенлохер опублікували свою реалізацію для дистанційної трансформації . Ви не можете використовувати його для об'ємних зображень, але, можливо, ви можете розширити його для підтримки 3d-даних. Я використовував це лише як чорний ящик.

У цьому документі розглядаються всі сучасні точні перетворення відстані:

"2D евклідові дистанційні перетворення: порівняльне опитування", обчислювальні дослідження обліку ACM, том 40, випуск 1, лютий 2008 р. Http://www.lems.brown.edu/~rfabbri/stuff/fabbri-EDT-survey-ACMCSurvFeb2008.pdf

У роботі цитується техніка від Meijster, et. ін. як найшвидше загальне призначення, точне перетворення. Ця методика детально описана тут:

"Загальний алгоритм обчислення дистанційних перетворень у лінійному часі", А. Мейстер, JBTM Roerdink та WH Гесселінк. http://fab.cba.mit.edu/classes/S62.12/docs/Meijster_distance.pdf

Алгоритм Meijster використовується в моїй бібліотеці ефектів з відкритим кодом: https://github.com/vinniefalco/LayerEffects

Я сподіваюся, що це комусь допоможе.

Ось код C # для 1D-евклідового перетворення в квадраті за даними статті Felzenszwald & Huttenlocher :

private static void DistanceTransform(double[] dataInput, ref double[] dataOutput)
{
    int n = dataInput.Length;

    int k = 0;
    int[] v = new int[n];
    double[] z = new double[n + 1];

    v[0] = 0;
    z[0] = Double.NegativeInfinity;
    z[1] = Double.PositiveInfinity;

    double s;

    for (int q = 1; q < n; q++)
    {
        while (true)
        {
            s = (((dataInput[q] + q * q) - (dataInput[v[k]] + v[k] * v[k])) / (2.0 * q - 2.0 * v[k]));

            if (s <= z[k])
            {
                k--;
            }
            else
            {
                break;
            }
        }

        k++;

        v[k] = q;
        z[k] = s;
        z[k + 1] = Double.PositiveInfinity;
    }

    k = 0;

    for (int q = 0; q < n; q++)
    {
        while (z[k + 1] < q)
        {
            k++;
        }

        dataOutput[q] = ((q - v[k]) * (q - v[k]) + dataInput[v[k]]);
    }
}

Це можна легко використовувати для бінарних зображень та зображень у градаціях сірого, застосовуючи його спочатку на стовпцях зображень, а потім у рядках (або навпаки, звичайно).

Перетворення справді дуже швидке.

Ось вихідні та вихідні зображення:

Чорні пікселі мають значення 0, а білі мають деяке велике значення (повинні бути більшими за найбільшу можливу відстань у квадраті на зображеннях, але не нескінченність), щоб перетворення повертало відстань від чорних пікселів, а білі були неміцними.

Щоб отримати справжню евклідову трансформацію відстані, просто візьміть квадратний корінь кожного пікселя з вихідного зображення.